Lock与Condition接口
前面两篇文章回顾了传统的synchronized关键字、JMM内存模型、volitile关键字,这篇文章开始我们正式介绍juc包。
在jdk5之后，juc提供了Lock，与synchronized相似，都可以实现锁功能，但是需要手动获取锁和释放锁。不过它与synchronized又不太一样，synchronized关键字相当于是使用的其它类的monitor关联，在mark word中记录锁的信息。而Lock则可以认为是一个锁对象
看看Lock源码的方法
public interface Lock { //获取锁 void lock(); // 获取锁，等待过程中响应中断 void lockInterruptibly() throws InterruptedException; // 尝试获取锁，不会阻塞，成功则返回true,否则返回false boolean tryLock(); // 尝试获取锁，如果获取不到则等待限定时间，超时未获取锁则返回false，可以响应中断 boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //释放锁 void unlock(); // 可以理解为wait、notify的替代方案 Condition newCondition(); }
简单应用下
public class Demo8 { private static int i = 0; public static void main(String[] args) throws InterruptedException { Lock lock = new ReentrantLock(); Runnable action = () -> { for (int j = 0; j < 100000; j++) { lock.lock(); i ++; lock.unlock(); } }; new Thread(action).start(); new Thread(action).start(); Thread.sleep(1000); System.out.println(i); } }
可以看到，使用Lock，是真正的在操作一个锁对象。
使用synchronized可以进行wait和notify
synchronized (Demo8.class) { Demo8.class.wait(); }
使用Lock配合condition接口可以实现类似功能。而且，使用synchronized关键字只能使用其加锁对象的wait和notify方法，只能有一个等待队列，就是加锁对象(如Demo8.class)的等待队列。而使用Lock和Condition则可以有多个等待队列。
来一起阅读下Condition类的源码
public interface Condition { // 对应wait()方法，需要signal()或者signalAll()唤醒，可以响应中断 void await() throws InterruptedException; // 等待，不响应中断 void awaitUninterruptibly(); // 等待指定时间(纳秒)，如果未超时被唤醒则返回剩余时间，超时返回false，可以响应中断 long awaitNanos(long nanosTimeout) throws InterruptedException; // 等待指定时间，如果未超时被唤醒则返回true，超时返回0或者负数，可以响应中断 boolean await(long time, TimeUnit unit) throws InterruptedException; // 指定明确的时间点，在该时间点前被唤醒则返回true，否则false，可以响应中断 boolean awaitUntil(Date deadline) throws InterruptedException; // 唤醒任一线程，该线程进入就绪状态 void signal(); // 唤醒所有线程 void signalAll(); }
下面实战使用下
public class Demo9 { public static void main(String[] args) throws InterruptedException { Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); new Thread(() -> { lock.lock(); System.out.println("await...."); try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("await finished"); lock.unlock(); }).start(); Thread.sleep(100); new Thread(() -> { lock.lock(); System.out.println("signal..."); condition.signal(); System.out.println("thread 2 finished"); lock.unlock(); }).start(); } }
输出的结果如下
await.... signal... thread 2 finished await finished
值的关注的一点是，不管使用await还是signal都要在获取锁的前提下。这与wait与notify实际上是一致的。不过，在使用了await以后，锁就被释放了，否则主线程也不可能继续执行。
和sychronized关键字不同的是，同一把锁可以创建多个Condition，每个Condition对象都拥有独立的等待队列。看如下代码
public class Demo9 { public static void main(String[] args) throws InterruptedException { Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); Condition condition1 = lock.newCondition(); new Thread(() -> { lock.lock(); System.out.println("await...."); try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("await finished"); lock.unlock(); }).start(); Thread.sleep(100); new Thread(() -> { lock.lock(); System.out.println("signal..."); condition1.signal(); System.out.println("thread 2 finished"); lock.unlock(); }).start(); } }
其输出结果如下。
await.... signal... thread 2 finished
显然，condition1的signal没能唤醒condition的await的线程。
当然，也并不是用了await就需要signal，因为可以限定时长
public class Demo10 { public static void main(String[] args) throws InterruptedException { Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); lock.lock(); try { System.out.println(condition.await(3, TimeUnit.SECONDS)); } finally { lock.unlock(); } } }
打印结果为false，因为超过3s也没有被唤醒
