Java并发编程：Lock

Posted 2021-11-27 smellpawn

一说到java的并发，机会想到锁。那最简单粗暴的保证线程安全的就是java关键字synchronized。那为什么还要Lock呢？  

先来说说 synchronized的缺点：

我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

　　1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

　　2）线程执行发生异常，此时JVM会让线程自动释放锁。

想想极端的情况， 万一调用sleep或者等待I/O没有释放锁，阻塞了，没有释放锁，那其他线程只能眼睁睁的看着，等待该线程被唤醒，执行完自动回收。这种情况与并发的意愿相违背。 那可咋整呢？

因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

lock的特点：

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

　　2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

想要了解一个方法，不看源码怎么行？

java.util.concurrent.locks包中常用的类和接口。

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

下面来逐个讲述Lock接口中每个方法的使用，

lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的

在Lock中声明了四个方法来获取锁，那么这四个方法有何区别呢？

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

　　由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

1 Lock lock = ...;
2 lock.lock();
3 try{
4     //处理任务
5 }catch(Exception ex){
6      
7 }finally{
8     lock.unlock();   //释放锁
9 }

tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

一般情况下通过tryLock来获取锁时是这样使用的：

 1 Lock lock = ...;
 2 if(lock.tryLock()) {
 3      try{
 4          //处理任务
 5      }catch(Exception ex){
 6          
 7      }finally{
 8          lock.unlock();   //释放锁
 9      } 
10 }else {
11     //如果不能获取锁，则直接做其他事情
12 }

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。（tryLock(long time)只是加上时间）。

例子1，lock()的正确使用方法

 1 public class Test {
 2     private ArrayList<Integer> arrayList = new ArrayList<Integer>();
 3     public static void main(String[] args)  {
 4         final Test test = new Test();
 5          
 6         new Thread(){
 7             public void run() {
 8                 test.insert(Thread.currentThread());
 9             };
10         }.start();
11          
12         new Thread(){
13             public void run() {
14                 test.insert(Thread.currentThread());
15             };
16         }.start();
17     }  
18      
19     public void insert(Thread thread) {
20         Lock lock = new ReentrantLock();    //注意这个地方
21         lock.lock();
22         try {
23             System.out.println(thread.getName()+"得到了锁");
24             for(int i=0;i<5;i++) {
25                 arrayList.add(i);
26             }
27         } catch (Exception e) {
28             // TODO: handle exception
29         }finally {
30             System.out.println(thread.getName()+"释放了锁");
31             lock.unlock();
32         }
33     }
34 }

结果为：

Thread-0得到了锁
Thread-1得到了锁
Thread-0释放了锁
Thread-1释放了锁

嗯？  为什么Thread1再Thread0释放锁之前得到了锁？

原因在于，在insert方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。

知道了原因改起来就比较容易了，只需要将lock声明为类的属性即可(j既将有注释的一行注释掉)。

例子2，tryLock()的使用方法

 1 public class Test {
 2     private ArrayList<Integer> arrayList = new ArrayList<Integer>();
 3     private Lock lock = new ReentrantLock();    //注意这个地方
 4     public static void main(String[] args)  {
 5         final Test test = new Test();
 6          
 7         new Thread(){
 8             public void run() {
 9                 test.insert(Thread.currentThread());
10             };
11         }.start();
12          
13         new Thread(){
14             public void run() {
15                 test.insert(Thread.currentThread());
16             };
17         }.start();
18     }  
19      
20     public void insert(Thread thread) {
21         if(lock.tryLock()) {
22             try {
23                 System.out.println(thread.getName()+"得到了锁");
24                 for(int i=0;i<5;i++) {
25                     arrayList.add(i);
26                 }
27             } catch (Exception e) {
28                 // TODO: handle exception
29             }finally {
30                 System.out.println(thread.getName()+"释放了锁");
31                 lock.unlock();
32             }
33         } else {
34             System.out.println(thread.getName()+"获取锁失败");
35         }
36     }
37 }

结果：

Thread-0得到了锁
Thread-1获取锁失败
Thread-0释放了锁