多线程18：Lock锁

Posted 2021-03-12 duanfu

Lock(锁):

• 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步，同步锁使用Lock对象充当
• java.util.concurrent.locks.Lock接口是控制多个线程对共享线程进行了访问的工具。锁提供了对共享资源的独占访问，每次只有一个线程对Lock对象加锁，线程开始访问共享资源的之前应先获得Lock对象
• ReentrantLock(可重入锁) 类实现了 Lock ， 它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock ， 可以显示加锁、释放锁。

 1 package com.thread.gaoji;
 2 
 3 import java.util.concurrent.locks.ReentrantLock;
 4 
 5 //测试Lock锁
 6 public class TestLock {
 7     public static void main(String[] args) {
 8         TestLock2 testLock2 = new TestLock2();
 9 
10         new Thread(testLock2).start();
11         new Thread(testLock2).start();
12         new Thread(testLock2).start();
13     }
14 }
15 
16 class TestLock2 implements Runnable {
17 
18     int ticketNums = 10;
19 
20     //定以lock锁
21     private final ReentrantLock lock = new ReentrantLock();
22 
23     @Override
24     public void run() {
25 
26         while (true) {
27             try {
28                 lock.lock();//加锁
29                 if (ticketNums > 0) {
30                     try {
31                         Thread.sleep(1000);
32                     } catch (InterruptedException e) {
33                         e.printStackTrace();
34                     }
35                     System.out.println(ticketNums--);
36                 } else {
37                     break;
38                 }
39             } finally {
40                 //解锁
41                 lock.unlock();
42             }
43         }
44     }
45 }
46 
47 结果：
48 10
49 9
50 8
51 7
52 6
53 5
54 4
55 3
56 2
57 1

 1 class A {
 2     private final ReentrantLock lock = new ReentrantLock();
 3 
 4     public void m() {
 5         lock.lock();
 6         try {
 7             //保证线程安全的代码;
 8         } finally {
 9             lock.unlock();
10             //如果同步代码有异常，要将unlock()写入finally语句块
11         }
12     }
13 }

sychronized 与 Lock 的对比

1. Lock是显示锁(手动开启和关闭，别忘记关闭锁) sychronized是隐式锁，出了作用域自动释放
2. Lock只有代码块锁，synchronized有代码块和方法锁
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
4. 优先使用顺序：Lock > 同步代码块(已经进入了方法体，分配了相应资源) > 同步方法(在方法体之外）