java并发学习01 --- Reentrantlock 和 Condition
本文是笔者看了《实战java高并发程序设计》之后加上自己的理解所写的笔记。
之所以直接从并发工具开始，是因为多线程的基础知识，例如多线程创建，常用的方法，以及synchronized，volatile关键字等知识之前学习的时候已经学习过许多遍了，但是java并发包却鲜有接触，这次决定写成博客，系列的总结一下。（之后有时间的话再把前面的知识补充上来，让这个系列更完整一些）
Reentrantlock（重入锁）
简单看一下它的用法：
重入锁基本代码演示：
package thread.thread_util; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 展示重入锁的用法 */ public class Lesson16_ReetrantLock { public static void main(String[] args) { Runnable target = new Runnable() { private Lock lock = new ReentrantLock(); @Override public void run() { lock.lock(); // lock.lock(); try { for (int i = 0; i < 5 ; i++) { System.out.println(Thread.currentThread().getId() + ": " + i); } } finally { lock.unlock(); // lock.unlock(); } } }; Thread t1 = new Thread(target); Thread t2 = new Thread(target); t1.start(); t2.start(); } }
重入到底是什么意思？
相比synchronized关键字，重入锁显示的调用了加锁和解锁的时机，但是为什么要叫重入锁呢？重入二字是什么意思呢？
重入的意思就是同一个线程可以反复进入同一个锁，上面的代码中就算把注释给去掉代码也是可以执行的。
当然这个代码例子仍然不够贴切，谁会没事加两把锁上去呢？但是你可以想象一下递归，我们都知道递归的每次操作都把相关的变量压入了一个栈之中，执行完成就弹出栈，然后再执行上一层函数，这里如果我们进行了加锁操作的话，那么每一层函数在递推的时候就都会加上一层锁，而在回归的时候函数结束，则会释放锁。重入锁的内部有一个计数器，每加一个锁，计数器就加1，释放一个锁，计数器就减1，只有当计数器为0时，锁才能被释放。
我们以经典的斐波那契数作为例子来展示一下。
深入理解“重入”代码演示：
package thread.thread_util; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 递归中的重入锁 */ public class Lesson16_ReentrantLock02 { public static void main(String[] args) { Runnable target = new Runnable() { private Lock lock = new ReentrantLock(); @Override public void run() { System.out.println(Thread.currentThread().getId()); System.out.println("最终结果为： " + fibonacci(3)); } public int fibonacci (int n) { try { lock.lock(); System.out.println(Thread.currentThread().getId() + "获得了锁"); if( n == 1 ) return 1; if( n == 2 ) return 1; return fibonacci(n-1) + fibonacci(n-2); } finally { lock.unlock(); System.out.println(Thread.currentThread().getId() + "释放了锁"); } } }; Thread thread = new Thread(target); thread.start(); } }
结果：
11
11获得了锁
11获得了锁
11释放了锁
11获得了锁
11释放了锁
11释放了锁
最终结果为： 2
我们可以看到这里总共获得了3次锁，释放了3次锁，整个锁才会被最终释放。
你可以再开一个线程进行验证，结果会类似下面这样：
11 11获得了锁 11获得了锁 11释放了锁 11获得了锁 11释放了锁 11释放了锁 最终结果为： 2 12 12获得了锁 12获得了锁 12释放了锁 12获得了锁 12释放了锁 12释放了锁 最终结果为： 2
重入锁的好基友：Condition对象
Condition的功能和Object.wait()与Object.notify()比较相似，它让我们可以控制某个线程什么时候开始等待，什么时候被唤醒，而不是由jvm来决定。
条件对象代码演示：
package thread.thread_util; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 展示条件对象的基本用法 * await * signal * signalAll */ public class Lesson17_Condition01 implements Runnable{ public static Lock lock = new ReentrantLock(); public static Condition condition = lock.newCondition(); @Override public void run() { try { lock.lock(); condition.await(); System.out.println("Thread is going on"); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } public static void main(String[] args) throws Exception{ Runnable target = new Lesson17_Condition01(); Thread thread = new Thread(target); thread.start(); Thread.sleep(2000); lock.lock(); condition.signal(); lock.unlock(); } }
这里在Runnable对象中，将对象锁住并让线程进入了休眠状态
主线程中进行了2秒钟的休眠，这2秒钟内子线程也无法执行，因为被“await()”了，直到2秒钟后，主线程再次开始执行，对线程进行了唤醒（signal）操作，唤醒操作也要进行加锁操作。
关于重入锁还有几点需要说明：
- 中断响应：对于synchronized来说，线程只有两种状态，要么获得锁开始执行，要么在队列中等待。
而对于重入锁来说，还存在另外一种状态，那就是中断线程，也就是把等待队列中的线程中断，那么这个中断有什么用呢？
比如说如果出现了死锁的情况，两个线程都在等待对方释放资源，那么这个时候如果我主动的中断一个线程，那么这个线程所持有的资源就被释放啦。我们来看看代码
重入锁中断响应代码演示：
package thread.thread_util; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 展示重入锁的中断响应功能 * 首先构造一个死锁 * 然后中断某个线程，释放资源 * 最后另外一个线程就可以获得释放的资源，完成线程的任务 */ public class Lesson16_ReentrantLock03 implements Runnable{ private static ReentrantLock lock1 = new ReentrantLock(); private static ReentrantLock lock2 = new ReentrantLock(); private int flag = 0; public void setFlag(int val) { this.flag = val; } @Override public void run() { try { if(flag == 1) { lock1.lockInterruptibly(); Thread.sleep(1000); lock2.lockInterruptibly(); System.out.println("Thread1 is going on "); } else { lock2.lockInterruptibly(); Thread.sleep(1000); lock1.lockInterruptibly(); System.out.println("Thread2 is going on "); } } catch (InterruptedException e) { e.printStackTrace(); } finally { if(lock1.isHeldByCurrentThread()){ lock1.unlock(); } if(lock2.isHeldByCurrentThread()){ lock2.unlock(); } } } public static void main(String[] args) { Lesson16_ReentrantLock03 target1 = new Lesson16_ReentrantLock03(); Lesson16_ReentrantLock03 target2 = new Lesson16_ReentrantLock03(); target1.setFlag(1); target2.setFlag(2); Thread thread1 = new Thread(target1); Thread thread2 = new Thread(target2); thread1.start(); thread2.start(); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } thread2.interrupt(); } }
- lockInterruptibly : 虽然锁住了对象，但是可以响应中断，发现中断之后就释放锁
Acquires the lock unless the current thread is interrupted. （文档说明）
最后线程2进行了中断，代码中的“else”里面的代码中的lockInterruptibly()方法就会使线程2 释放lock2并放弃对lock1的请求。
运行结果：
Thread1 is going on java.lang.InterruptedException at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222) at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335) at thread.thread_util.Lesson16_ReentrantLock03.run(Lesson16_ReentrantLock03.java:33) at java.lang.Thread.run(Thread.java:748) Process finished with exit code 0
锁申请等待时限（tryLock）
这是主动的中断，还有另外一种更为简便的方法，就是给锁的申请添加时限，如果规定时间内我还没得到锁，那我就不要这把锁了
trylock() 代码演示：
package thread.thread_util; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantLock; public class Lesson16_ReentrantLock04 implements Runnable{ private static ReentrantLock lock = new ReentrantLock(); @Override public void run () { try { if(lock.tryLock(3,TimeUnit.SECONDS)){ System.out.println(Thread.currentThread().getName() + " get lock successful"); Thread.sleep(4000); } else { System.out.println(Thread.currentThread().getName() + " get lock failed"); } } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) { Lesson16_ReentrantLock04 target = new Lesson16_ReentrantLock04(); Thread t1 = new Thread(target); Thread t2 = new Thread(target); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }
这里线程1先获得了锁，然后睡眠6秒钟（sleep并不会释放锁），所以线程2在3秒钟内都无法获得所最后进入else代码段。
最后结果：
线程1 get lock successful
线程2 get lock failed
关于重入锁和条件对象暂时就写到这里。
