JAVA并发包——锁

1.java多线程中，可以使用synchronized关键字来实现线程间的同步互斥工作，其实还有个更优秀的机制来完成这个同步互斥的工作——Lock对象，主要有2种锁：重入锁和读写锁，它们比synchronized具有更强大的功能，并且有嗅探锁定、多路分支等功能。

2.ReentrantLock（重入锁）

重入锁，在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，否则会造成锁永远无法释放，其他线程永远进不来的结果（使用起来跟synchronized很像，并且，在jdk1.8之前，ReentrantLock比synchronized性能好，jdk1.8对synchronized做了优化，性能接近了。但是ReentrantLock比synchronized灵活）

代码示例：

 1 package lock020;
 2
 3 import java.util.concurrent.locks.Lock;
 4 import java.util.concurrent.locks.ReentrantLock;
 5
 6 public class UseReentrantLock {
 7
 8     private Lock lock = new ReentrantLock();
 9
10     public void method1(){
11         try {
12             lock.lock();
13             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
14             Thread.sleep(1000);
15             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
16             Thread.sleep(1000);
17         } catch (InterruptedException e) {
18             e.printStackTrace();
19         } finally {
20
21             lock.unlock();
22         }
23     }
24
25     public static void main(String[] args) {
26
27         final UseReentrantLock ur = new UseReentrantLock();
28         Thread t1 = new Thread(new Runnable() {
29             @Override
30             public void run() {
31                 ur.method1();
32             }
33         }, "t1");
34
35         t1.start();
36
37         Thread t2 = new Thread(new Runnable() {
38             @Override
39             public void run() {
40                 ur.method1();
41             }
42         }, "t2");
43
44         t2.start();
45
46         try {
47             Thread.sleep(10);
48         } catch (InterruptedException e) {
49             e.printStackTrace();
50         }
51         //System.out.println(ur.lock.getQueueLength());
52     }
53
54
55 }

执行以后，可以发现，t1和t2是串行执行method1的

3.ReentrantLock锁的等待与通知

synchronized关键字里，有Object的wait()方法和notify()/notifyAll()方法进行多线程之间的工作协调。而同样的，Lock也有自己的等待/通知类，它就是Condition。这个Condition一定是针对某一把具体的锁的，就是说，只有有锁的基础之才会产生Condition

代码实现：

 1 package lock020;
 2
 3 import java.util.concurrent.locks.Condition;
 4 import java.util.concurrent.locks.Lock;
 5 import java.util.concurrent.locks.ReentrantLock;
 6
 7 public class UseCondition {
 8
 9     private Lock lock = new ReentrantLock();
10     private Condition condition = lock.newCondition();
11
12     public void method1(){
13         try {
14             lock.lock();
15             System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
16             Thread.sleep(3000);
17             System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
18             condition.await();    // Object wait，释放锁
19             System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
20         } catch (Exception e) {
21             e.printStackTrace();
22         } finally {
23             lock.unlock();
24         }
25     }
26
27     public void method2(){
28         try {
29             lock.lock();
30             System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
31             Thread.sleep(3000);
32             System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
33             condition.signal();        //Object notify
34         } catch (Exception e) {
35             e.printStackTrace();
36         } finally {
37             lock.unlock();
38         }
39     }
40
41     public static void main(String[] args) {
42
43         final UseCondition uc = new UseCondition();
44         Thread t1 = new Thread(new Runnable() {
45             @Override
46             public void run() {
47                 uc.method1();
48             }
49         }, "t1");
50         Thread t2 = new Thread(new Runnable() {
51             @Override
52             public void run() {
53                 uc.method2();
54             }
55         }, "t2");
56
57         t1.start();
58         t2.start();
59     }
60
61
62
63 }

以上代码，实现了wait/nofity的功能

ps：不同的线程之间，可以用不同的Condition对象来进行通信。例如t1唤醒t2用 Condition1，t3唤醒t4用Condition2，这也是比wait/notify灵活的地方

3.公平锁和非公平锁

公平锁的作用就是严格按照线程启动的顺序来执行的，不允许其他线程插队执行的；而非公平锁是允许插队的。（默认是非公平锁）

可以通过构造方法指定参数是ture（公平）或者false（非公平），一般说来，非公平锁比公平锁性能要好，因为公平锁要维护顺序

4.ReentrantLock锁与synchronized的区别

类别	synchronized	Lock
存在层次	Java的关键字，在jvm层面上	是一个类
锁的释放	1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁	在finally中必须释放锁，不然容易造成线程死锁
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待
锁状态	无法判断	可以判断
锁类型	可重入 不可中断 非公平	可重入 可判断 可公平（两者皆可）
性能	少量同步	大量同步

5.ReenTrantReadWriteLock（读写锁）

核心其实就是实现读写分离。在高并发的情况下，尤其是读多写少的情况下，性能远高于重入锁

之前的ReentrantLock和synchronized的使用时，同一时间内，只能一个线程访问被锁定的代码。读写锁不同，其本质是2个锁，即读锁和写锁。在读锁下，多个线程可以并发访问，但是在写锁下，只能串行访问

口诀：读读共享，写写互斥，读写互斥

代码示例：

 1 package lock021;
 2
 3 import java.util.concurrent.locks.ReentrantReadWriteLock;
 4 import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
 5 import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
 6
 7 public class UseReentrantReadWriteLock {
 8
 9     private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
10     private ReadLock readLock = rwLock.readLock();
11     private WriteLock writeLock = rwLock.writeLock();
12
13     public void read(){
14         try {
15             readLock.lock();
16             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
17             Thread.sleep(3000);
18             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
19         } catch (Exception e) {
20             e.printStackTrace();
21         } finally {
22             readLock.unlock();
23         }
24     }
25
26     public void write(){
27         try {
28             writeLock.lock();
29             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
30             Thread.sleep(3000);
31             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
32         } catch (Exception e) {
33             e.printStackTrace();
34         } finally {
35             writeLock.unlock();
36         }
37     }
38
39     public static void main(String[] args) {
40
41         final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
42
43         Thread tr1 = new Thread(new Runnable() {
44             @Override
45             public void run() {
46                 urrw.read();
47             }
48         }, "t1");
49         Thread tr2 = new Thread(new Runnable() {
50             @Override
51             public void run() {
52                 urrw.read();
53             }
54         }, "t2");
55         Thread tw3 = new Thread(new Runnable() {
56             @Override
57             public void run() {
58                 urrw.write();
59             }
60         }, "t3");
61         Thread tw4 = new Thread(new Runnable() {
62             @Override
63             public void run() {
64                 urrw.write();
65             }
66         }, "t4");
67
68         tr1.start();
69         tr2.start();
70
71         tw3.start();
72         tw4.start();
73
74     }
75 }

模拟代码可发现：

如果是都是读操作，基本是同时进行的

如果有写操作，是要锁定的

6.锁的优化

（1）避免死锁

（2）减小锁的持有时间

（3）减小锁的粒度

（4）锁的分离

（5）尽量使用无锁的操作，如原子操作（Atomic类系列）、volatile关键字

7.分布式锁的概念

2台机器都部署了项目，显然，运行的jvm是不同的，如果t1线程在机器A，t2线程在机器B，同时要访问同一段锁定的代码块

显然，jvm的锁机制是无法处理这种情况的，这时候要考虑第三方帮助实现，如zookkeeper