java ReentrantLock可重入锁功能

1、可重入锁是可以中断的，如果发生了死锁，可以中断程序

//如下程序出现死锁，不去kill jvm无法解决死锁
public class Uninterruptible {
public static void main(String[] args) throws InterruptedException {
final Object o1 = new Object(); final Object o2 = new Object();
Thread t1 = new Thread() {
public void run() {
try {
synchronized(o1) {
Thread.sleep(1000);
synchronized(o2) {}
}
} catch (InterruptedException e) { System.out.println("t1 interrupted"); }
}
};
Thread t2 = new Thread() {
public void run() {
try {
synchronized(o2) {
Thread.sleep(1000);
synchronized(o1) {}
}
} catch (InterruptedException e) { System.out.println("t2 interrupted"); }
}
};
t1.start();
t2.start();
Thread.sleep(2000);
t1.interrupt(); 
t2.interrupt();
t1.join(); 
t2.join();
}
}

然后是解决方法：We can reimplement our threads using Reentrant-Lock instead of intrinsic locks, and we can use its lockInterruptibly() method

Thread A先取得lock，Thread B无法取得lock进入block状态，可以透过发出interrupt方式唤醒Thread B,这就是和lock的区别

• lock()：若lock被thread A取得，thread B会进入block状态，直到取得lock。
• tryLock()：若当下不能取得lock，thread就会放弃。
• lockInterruptibly()：跟lock()情況一下，但是thread B可以透过interrupt被唤醒处理InterruptedException。

final ReentrantLock l1 = new ReentrantLock();
final ReentrantLock l2 = new ReentrantLock();
Thread t1 = new Thread() {
public void run() {
try {
➤ l1.lockInterruptibly();
Thread.sleep(1000);
➤ l2.lockInterruptibly();
} catch (InterruptedException e) { System.out.println("t1 interrupted"); }
}
};
Thread t2 = new Thread() {
public void run() {
try {
➤ l2.lockInterruptibly();
Thread.sleep(1000);
➤ l1.lockInterruptibly();
} catch (InterruptedException e) { System.out.println("t2 interrupted"); }
}
};


t1.start();
t2.start();
Thread.sleep(2000);
t1.interrupt(); //当执行到时，线程会捕获InterruptedException程序会结束
t2.interrupt();
t1.join(); 
t2.join();
}

2、设置锁超时时间

• tryLock()：若线程一定时间不能取得lock，thread就会放弃。

public class LockTimeOut{
private ReentrantLock leftChopstick, rightChopstick;
public void method(){
Thread.sleep(random.nextInt(1000)); // Think for a while
leftChopstick.lock();
try {
➤ if (rightChopstick.tryLock(1000, TimeUnit.MILLISECONDS)) {
// Got the right chopstick
………
}

}

　　

说明：Instead of using lock(), this code uses tryLock(), which times out if it fails to acquire the lock

3、条件变量,所谓的  Condition: await()/signal()，可以实现每个关注自己的信号量，每个人有每个人的信号量

When you use Condition: await()/signal() you can distinguish which object or group of objects/threads get a specific signal.

Here is a short example where some threads, the producers, will get the isEmpty signal while the consumers will get the isFull signal:

这里会有两个信号量，生产者和消费这关注的信号量是不一样的，每个人有每个人关注的信号量

private volatile boolean usedData = true;//mutex for data
private final Lock lock = new ReentrantLock();
private final Condition isEmpty = lock.newCondition();//生产者关心 isEmpty信号量
private final Condition isFull = lock.newCondition();

public void setData(int data) throws InterruptedException {
    lock.lock();
    try {

        while(!usedData) {//wait for data to be used如果数据为没有消费，那么就会阻塞到 isEmpty信号量，生产者等待这个空信号量
            isEmpty.await();
        }
        this.data = data;
        isFull.signal();//broadcast that the data is now full.  释放 isFull满这个信号量
        usedData = false;//tell others I created new data.          
    }finally {
        lock.unlock();//interrupt or not, release lock
    }       
}

public void getData() throws InterruptedException{
    lock.lock();
    try {
        while(usedData) {//usedData is lingo for empty  这里都必须是循环，因为 从await（）这个函数 退出阻塞说明条件可能满足，不是一定满足
            isFull.await();
        }
        isEmpty.signal();//tell the producers to produce some more.
        usedData = true;//tell others I have used the data.
    }finally {//interrupted or not, always release lock
        lock.unlock();
    }       
}

然后注意信号量和 条件是不一样的东西

if the condition is not true, it calls await(), which atomically unlocks the lock and blocks on the condition variable.

When another thread calls signal() or signalAll() to indicate that the condition might now be true, await() unblocks and automatically reacquires the lock. An important point is that when await() returns, it only indicates that the condition might be true. This is why await() is called within a loop—we need to go back,recheck whether the condition is true, and potentially block on await() again if necessary.

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
lock.lock();
try {
while (!<<condition is true>>) //如果条件不满足
   condition.await();
<<use shared resources>>
} finally { lock.unlock(); }

然后是具体实例

private void think() throws InterruptedException {
table.lock();
try {
eating = false;
left.condition.signal();//释放条件变量
right.condition.signal();//释放条件变量
} finally { table.unlock(); }
Thread.sleep(1000);
}
private void eat() throws InterruptedException {
table.lock();
try {
13 while (left.eating || right.eating)
14 condition.await();
eating = true;
} finally { table.unlock(); }
Thread.sleep(1000);
}