Java多线程学习之Lock与ReentranLock详解

1 public interface Lock {
2     void lock();
3     void lockInterruptibly() throws InterruptedException;
4     Condition newCondition();
5     boolean tryLock();
6     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
7     void unlock();
8 }

 1 // 创建锁
 2 Lock lock = new ReentranLock();
 3 ...
 4   
 5 lock.lock();
 6 try{
 7     // 进行必要操作
 8       // 捕获异常，并在必要时恢复不变性条件
 9 }finally{
10   //释放锁
11   lock.unlock();
12 }

 1 // 资源类
 2 public class Resource {
 3     //资源总和
 4     private int resourceNum;
 5     // 显示锁
 6     public Lock lock = new ReentrantLock();
 7 
 8     public Resource(int resourceNum){
 9         this.resourceNum = resourceNum;
10     }
11     //返回此资源的总量
12     public int getResourceNum(){
13         return resourceNum;
14     }
15 }

 1 public class LockTest1 {
 2       //传入两个资源类和预期操作时间，在此期间内返回两个资源的数量总和
 3     public int getResource(Resource resourceA, Resource resourceB, long timeout, TimeUnit unit)
 4           throws InterruptedException {
 5         // 获取当前时间，算出操作截止时间
 6         long stopTime = System.nanoTime() + unit.toNanos(timeout);
 7 
 8         while(true){
 9             try {
10                 // 尝试获得资源A的锁
11                 if (resourceA.lock.tryLock()) {
12                     try{
13                         // 如果获得资源A的锁，尝试获得资源B的锁
14                         if(resourceB.lock.tryLock()){
15                             //同时获得两资源的锁，进行相关操作后返回
16                             return getSum(resourceA, resourceB);
17                         }
18                     }finally {
19                         resourceB.lock.unlock();
20                     }
21                 }
22             }finally {
23                 resourceA.lock.unlock();
24             }
25           
26             // 判断当前是否超时，规定-1为错误标识
27             if(System.nanoTime() > stopTime)
28                 return -1;
29             
30             //睡眠1秒，继续尝试获得锁
31             TimeUnit.SECONDS.sleep(1);
32         }
33     }
34     
35     // 获得资源总和
36     public int getSum(Resource resourceA,Resource resourceB){
37         return resourceA.getResourceNum()+resourceB.getResourceNum();
38     }
39 }

 1 public class InterruptedLockTest implements Runnable{
 2     public synchronized void doCount(){
 3         //使用死循环表示此操作要进行很长的一段时间才能结束
 4         while(true){}
 5     }
 6 
 7     @Override
 8     public void run() {
 9         doCount();
10     }
11 }

 1 public static void main(String[] args) throws InterruptedException {
 2         InterruptedLockTest test = new InterruptedLockTest();
 3 
 4         Thread t1 = new Thread(test);
 5         Thread t2 = new Thread(test);
 6 
 7         t1.start();
 8         t2.start();
 9 
10           //等待两秒，尝试中断线程t2的等待
11         TimeUnit.SECONDS.sleep(2);
12         t2.interrupt();
13 
14         //等待1秒，让 t2.interrupt(); 执行生效
15         TimeUnit.SECONDS.sleep(1);
16         System.out.println("线程t1是否存活：" + t1.isAlive());
17         System.out.println("线程t2是否存活：" + t2.isAlive());
18     }

 1 public class InterruptedLockTest2 implements Runnable{
 2     Lock lock = new ReentrantLock();
 3 
 4     public void doCount() throws InterruptedException {
 5         //可中断的锁等待机制，会抛出中断异常
 6         lock.lockInterruptibly();
 7         try {
 8             while (true) {}
 9         }finally {
10             lock.unlock();
11         }
12     }
13 
14     @Override
15     public void run() {
16         try {
17             doCount();
18         } catch (InterruptedException e) {
19             System.out.println("被中断....");
20         }
21     }
22 }

 1 public static void main(String[] args) throws InterruptedException {
 2     InterruptedLockTest2 test = new InterruptedLockTest2();
 3 
 4     Thread t1 = new Thread(test);
 5     Thread t2 = new Thread(test);
 6 
 7     t1.start();
 8     t2.start();
 9 
10     TimeUnit.SECONDS.sleep(2);
11     t2.interrupt();
12 
13     //等待1秒，让 t2.interrupt(); 执行生效
14     TimeUnit.SECONDS.sleep(1);
15     System.out.println("线程t1是否存活：" + t1.isAlive());
16     System.out.println("线程t2是否存活：" + t2.isAlive());
17 }

1 // 也可以指定公平性
2 public ReentrantLock(boolean fair) {
3     sync = fair ? new FairSync() : new NonfairSync();
4 }
5 //默认创建非公平锁
6 public ReentrantLock() {
7       sync = new NonfairSync();
8 }