Java并发编程:Lock

时间:2021-08-22 20:51:33

一说到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释放了锁