java lock类是干什么的 java中为什么要用Object定义锁lock
大家好，感谢邀请，今天来为大家分享一下java lock类是干什么的的问题，以及和java中为什么要用Object定义锁lock的一些困惑，大家要是还不太明白的话，也没有关系，因为接下来将为大家分享，希望可以帮助到大家，解决大家的问题，下面就开始吧！
关于java的lock和condition
1、在某些情况下，当内部锁非常不灵活时，显式锁就可以派上用场。内部条件队列有一些缺陷，每个内部锁只能有一个与之相关联的条件队列。
2、使用显式的Lock和Condition的实现类提供了一个比内部锁和条件队列更加灵活的选择。一个Condition和一个单独的Lock相关联，就像条件队列和单独的内部锁相关联一样。每个锁可以有多个等待集、中断性选择、基于时限、公平性选择等。
public interface Condition{
void await() throws InterruptedException;//相当于wait
boolean await(long time,TimeUnit unit) throws InterruptedException;
long awaitNanos(long nanosTimeout) throws InterruptedException;
void awaitUninterruptibly();
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();//相当于notify
void signalAll();//相当于notifyall
}
调用与Condition相关联的Lock的Lock.newCondition方法，可创建一个Condition.
3、有限缓存操作
@ThreadSafe
public class ConditionBoundedBuffer<T>{
protected final Lock lock=new ReentrantLock();
private final Condition notFull=lock.newCondition();
private final Condition notEmpty=lock.newCondition();
@GuardBy("lock");
private final T[] items=(T[]) new Object[BUFFER_SIZE];
@GuardBy("lock") private int tail,head,count;
public void put(T x) throws InterruptedExceptoin{
lock.lock();
try{
while(count=items.lentgh)
notFull.await();
items[tail]=x;
if(++tail=items.length)
tail=0;
++count;
notEmpty.signal();
}
finally{lock.unlock();
}
}
public T take() throws InterruptedException{
lock.lock();
try{
while(count=items.lentgh)
notEmpty.await();
T x=items[head];
items[head]=null;
if(++head=items.length)
head=0;
--count;
notFull.signal();
return x;
}
finally{lock.unlock();
}
}
}
java中为什么要用Object定义锁lock
主要为了多线程访问共享资源时，保证只能有一个线程操作资源，比如说一个servlet中对根据参数
一个公共变量设置值
，如果不采用lock那么在并发访问时就无法保证每个线程中公共变量设置的值都是各自线程的，在后续的应用中变量的值可能会错乱，加了lock之后就保证了在一个线程中从头到尾都是一致的
Java中Lock,tryLock,lockInterruptibly有什么区别
ReentrantLock锁有好几种，除了常用的lock，tryLock，其中有个lockInterruptibly。
先把API粘贴上来
lock
public void lock()
获取锁。
如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。
如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。
如果该锁被另一个线程保持，则出于线程调度的目的，禁用当前线程，并且在获得锁之前，该线程将一
直处于休眠状态，此时锁保持计数被设置为 1。
指定者：
接口 Lock中的 lock
lockInterruptibly
public void lockInterruptibly() throws InterruptedException
1）如果当前线程未被中断，则获取锁。
2）如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。
3）如果当前线程已经保持此锁，则将保持计数加 1，并且该方法立即返回。
4）如果锁被另一个线程保持，则出于线程调度目的，禁用当前线程，并且在发生以下两种情况之一以
前，该线程将一直处于休眠状态：
1）锁由当前线程获得；或者
2）其他某个线程中断当前线程。
5）如果当前线程获得该锁，则将锁保持计数设置为 1。
如果当前线程：
1）在进入此方法时已经设置了该线程的中断状态；或者
2）在等待获取锁的同时被中断。
则抛出 InterruptedException，并且清除当前线程的已中断状态。
6）在此实现中，因为此方法是一个显式中断点，所以要优先考虑响应中断，而不是响应锁的普通获取或
重入获取。
指定者：接口 Lock中的 lockInterruptibly
抛出： InterruptedException如果当前线程已中断。
tryLock public boolean tryLock()
仅在调用时锁未被另一个线程保持的情况下，才获取该锁。
1）如果该锁没有被另一个线程保持，并且立即返回 true值，则将锁的保持计数设置为 1。
即使已将此锁设置为使用公平排序策略，但是调用 tryLock()仍将立即获取锁（如果有可用的），
而不管其他线程当前是否正在等待该锁。在某些情况下，此“闯入”行为可能很有用，即使它会打破公
平性也如此。如果希望遵守此锁的公平设置，则使用 tryLock(0, TimeUnit.SECONDS)
，它几乎是等效的（也检测中断）。
2）如果当前线程已经保持此锁，则将保持计数加 1，该方法将返回 true。
3）如果锁被另一个线程保持，则此方法将立即返回 false值。
指定者：
接口 Lock中的 tryLock
返回：
如果锁是自由的并且被当前线程获取，或者当前线程已经保持该锁，则返回 true；否则返回
false
关于中断又是一段很长的叙述，先不谈。
1）lock(),拿不到lock就不罢休，不然线程就一直block。比较无赖的做法。
2）tryLock()，马上返回，拿到lock就返回true，不然返回false。比较潇洒的做法。
带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false。比较聪明的做法。
3）lockInterruptibly()就稍微难理解一些。
先说说线程的打扰机制，每个线程都有一个打扰标志。这里分两种情况，
1.线程在sleep或wait,join，此时如果别的进程调用此进程的 interrupt（）方法，此线程会被唤醒并被要求处理InterruptedException；(thread在做IO操作时也可能有类似行为，见java thread api)
2.此线程在运行中，则不会收到提醒。但是此线程的“打扰标志”会被设置，可以通过isInterrupted()查看并作出处理。
lockInterruptibly()和上面的第一种情况是一样的，线程在请求lock并被阻塞时，如果被interrupt，则“此线程会被唤醒并被要求处理InterruptedException”。并且如果线程已经被interrupt，再使用lockInterruptibly的时候，此线程也会被要求处理interruptedException
先看lock()方法
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/**
*@author作者E-mail:
*@version创建时间：2015-10-23下午01:47:03类说明
*/
publicclassTestLock
{
//@Test
publicvoidtest()throwsException
{
finalLocklock=newReentrantLock();
lock.lock();
Threadt1=newThread(newRunnable()
{
@Override
publicvoidrun()
{
lock.lock();
System.out.println(Thread.currentThread().getName()+"interrupted.");
}
},"childthread-1");
t1.start();
Thread.sleep(1000);
t1.interrupt();
Thread.sleep(1000000);
}
publicstaticvoidmain(String[]args)throwsException
{
newTestLock().test();
}
}
用eclipse对这个程序进行debug发现，即使子线程已经被打断，但是子线程仍然在run，可见lock()方法并不关心线程是否被打断，甚至说主线程已经运行完毕，子线程仍然在block().
而使用LockInterupptibly，则会响应中断
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/**
*@author作者E-mail:
*@version创建时间：2015-10-23下午01:53:10类说明
*/
publicclassTestLockInterruptibly
{
//@Test
publicvoidtest3()throwsException
{
finalLocklock=newReentrantLock();
lock.lock();
Threadt1=newThread(newRunnable()
{
@Override
publicvoidrun()
{
try
{
lock.lockInterruptibly();
}
catch(InterruptedExceptione)
{
System.out.println(Thread.currentThread().getName()+"interrupted.");
}
}
},"childthread-1");
t1.start();
Thread.sleep(1000);
t1.interrupt();
Thread.sleep(1000000);
}
publicstaticvoidmain(String[]args)throwsException
{
newTestLockInterruptibly().test3();
}
}
try{
Thread.sleep(2000);
lock.lockInterruptibly();
}catch(InterruptedException e){
System.out.println(Thread.currentThread().getName()+" interrupted.");
}
t1.start();
t1.interrupt();
Thread.sleep(1000000);
如果将代码改成这样，那么将会在在阻塞之前已经中断，此时再lockInterruptibly()也是会相应中断异常的
文章到此结束，如果本次分享的java lock类是干什么的和java中为什么要用Object定义锁lock的问题解决了您的问题，那么我们由衷的感到高兴！