java并发库--锁

Posted 2020-06-14

• synchronized的缺陷：

　　被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，获取线程被阻塞时，没有释放锁会导致等待线程无期限的等待下去。另外，多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。Lock还可以知道线程有没有成功获取到锁。

• Lock和synchronized的比较

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

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

• java.util.concurrent.locks包下常用的类

　　1）Lock

　　lock接口的源代码

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 newCondition();
8 }

　　方法详细介绍参考API。

　　2）ReentrantLock

　　一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

　　实例：

 1 public class LockTest {
 2     public static void main(String[] args) {
 3         final Output output = new Output();
 4         while(true){
 5             new Thread(new Runnable() {
 6                 @Override
 7                 public void run() {
 8                     output.output("love");
 9                 }
10             }).start();
11             new Thread(new Runnable() {
12                 @Override
13                 public void run() {
14                     output.output("hate");
15                 }
16             }).start();
17         }
18         
19     }
20     
21 }    
22 class Output{
23     Lock lock = new ReentrantLock();
24     public void output(String str){
25         lock.lock();
26         try {
27             for (int i = 0; i < str.length(); i++) {
28                 System.out.print(str.charAt(i));
29             }
30             System.out.println();
31         } catch (Exception e) {
32             e.printStackTrace();
33         } finally{
34             lock.unlock();
35         }
36         
37         
38     }
39 }

　　3）ReadWriteLock

　　ReadWriteLock接口源代码，它只提供了获取写入锁和读取锁的方法

 1 public interface ReadWriteLock {
 2     /**
 3      * Returns the lock used for reading.
 4      *
 5      * @return the lock used for reading.
 6      */
 7     Lock readLock();
 8  
 9     /**
10      * Returns the lock used for writing.
11      *
12      * @return the lock used for writing.
13      */
14     Lock writeLock();
15 }

　　一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。

　　4）ReentrantReadWriteLock

　　ReentrantReadWriteLock类的几个属性：

• 获取顺序：此类不会将读取者优先或写入者优先强加给锁访问的排序。但是，它确实支持可选的公平 策略。
• 重入：此锁允许 reader 和 writer 按照 ReentrantLock 的样式重新获取读取锁或写入锁。在写入线程保持的所有写入锁都已经释放后，才允许重入 reader 使用它们。此外，writer 可以获取读取锁，但反过来则不成立。在其他应用程序中，当在调用或回调那些在读取锁状态下执行读取操作的方法期间保持写入锁时，重入很有用。如果 reader 试图获取写入锁，那么将永远不会获得成功。 
• 锁降级：重入还允许从写入锁降级为读取锁，其实现方式是：先获取写入锁，然后获取读取锁，最后释放写入锁。但是，从读取锁升级到写入锁是不可能的。 
• 锁获取的中断：读取锁和写入锁都支持锁获取期间的中断。 

　　实例：分别用三个线程进行读取和写入数据。

 1 public class ReadWriteLockTest {
 2     public static void main(String[] args) {
 3         final Date date = new Date();
 4             for (int i = 0; i < 3; i++) {
 5                 new Thread(new Runnable() {
 6                     @Override
 7                     public void run() {
 8                         while(true){
 9                             date.put();
10                         }
11                     }
12                 }).start();
13                 new Thread(new Runnable() {
14                     
15                     @Override
16                     public void run() {
17                         while(true){
18                             date.get();
19                         }
20                     }
21                 }).start();
22         }
23         
24     }
25 }
26 
27 class Date{
28     
29     ReadWriteLock rwl = new ReentrantReadWriteLock();
30     
31     private Integer date;
32     
33     public void get(){
34         rwl.readLock().lock();
35         try {
36             System.out.println(Thread.currentThread().getName()+"准备读取数据");
37             System.out.println(Thread.currentThread().getName()+"读取数据:"+date);
38         } catch (Exception e) {
39             // TODO: handle exception
40         } finally{
41             rwl.readLock().unlock();
42         }
43         
44     }
45     
46     public void put(){
47         rwl.writeLock().lock();
48         try {
49             System.out.println(Thread.currentThread().getName()+"准备写入数据");
50             Thread.sleep(50);
51             date = new Random().nextInt(5000);
52             System.out.println(Thread.currentThread().getName()+"写入数据:"+date);
53         } catch (Exception e) {
54             // TODO: handle exception
55         } finally{
56             rwl.writeLock().unlock();
57         }
58     }
59 }

　　这样子，读中有读，读中没有写，写中也没有写，大大提升了读操作的效率。

　　5）Lock和synchronized的选择

　　总结来说，Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

　　5）Lock可以提高多个线程进行读操作的效率。

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

• 锁的相关概念介绍

　　1）可重入锁

　　如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

1 class MyClass {
2     public synchronized void method1() {
3         method2();
4     }
5     public synchronized void method2() {
6          
7     }
8 }

　　上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

　　2）可中断锁

　　可中断锁：顾名思义，就是可以响应中断的锁。

　　在Java中，synchronized就不是可中断锁，而Lock是可中断锁。

　　如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

　　在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性。

　　3）公平锁

　　公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

　　非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

　　在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

　　而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

　　4）读写锁

　　读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

　　正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

　　ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

　　可以通过readLock()获取读锁，通过writeLock()获取写锁。

　　缓存一般涉及到读写，那么就可以应用锁来实现缓存系统，下面将实现缓存系统的核心代码：

 1 public class CacheDemo {
 2     
 3     private Map<String, Object> map = new HashMap<String, Object>();//缓存map
 4     private ReadWriteLock rwl = new ReentrantReadWriteLock();
 5     private ReadLock readLock = (ReadLock) rwl.readLock();//读锁
 6     private WriteLock writeLock = (WriteLock) rwl.writeLock();//写锁
 7     
 8     public Object getValue(String key){
 9         readLock.lock();
10         Object value = null;
11         try {
12             value = map.get(key);
13             if(value == null){//如果对象为空，读锁释放
14                 readLock.unlock();
15                 writeLock.lock();//获取写锁，保证同步
16                 try {
17                     if(value == null){//再次判断对象是否为空，防止多线程访问重复写入，影响效率
18                         value = "abcd";//获取缓存数据
19                     }
20                     map.put(key, value);
21                 } catch (Exception e) {
22                     // TODO: handle exception
23                 } finally{
24                     /**
25                      * 将写锁降级为读锁
26                      */
27                     readLock.lock();
28                     writeLock.unlock();
29                 }
30             }
31         } catch (Exception e) {
32             // TODO: handle exception
33         } finally{
34             readLock.unlock();
35         }
36         
37         return value;
38     }
39 }

参考资料：

http://www.cnblogs.com/dolphin0520/p/3923167.html

javaAPI