并发编程——ReentrantLock_reentrantlock 每隔1秒 尝试获取锁

如果有兴趣了解更多相关内容，欢迎来我的个人网站看看：耶瞳空间

一：基本介绍

从Java 5开始，引入了一个高级的处理并发的java.util.concurrent包，它提供了大量更高级的并发功能，能大大简化多线程程序的编写。我们知道Java语言直接提供了synchronized关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。而java.util.concurrent.locks包提供的ReentrantLock用于替代synchronized加锁。

Lock是Java并发编程中很重要的一个接口，它要比synchronized关键字更能直译"锁"的概念，Lock需要手动加锁和手动解锁，一般通过lock.lock()方法来进行加锁，通过lock.unlock()方法进行解锁。一般会在finally块中写unlock( )以防死锁。而ReentrantLock实现了Lock接口。

ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”。可重入表示ReentrantLock锁可以被同一个线程多次获取而不会出现死锁。ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。

ReentrantLock和synchronized比较

• synchronized是Java语言层面提供的语法，而ReentrantLock是Java代码实现的锁。
• synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。
• synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以响应中断。

基本使用示例：

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock();
        try {
            count += n;
        } finally {
            lock.unlock();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

二：可重入

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

示例代码如下：

public class Demo {
  static Lock lock = new ReentrantLock();

  public static void main(String[] args) {
    method1();
  }

  public static void method1() {
    lock.lock();
    try {
      System.out.println("execute method1");
      method2();
    } finally {
      lock.unlock();
    }
  }

  public static void method2() {
    lock.lock();
    try {
      System.out.println("execute method2");
    } finally {
      lock.unlock();
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

三：可打断

public class Demo {
  static Lock lock = new ReentrantLock();

  public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
      try {
        // 如果没有竞争，那么此方法就会获取lock对象锁
        // 如果有竞争，就会进入阻塞队列，可以被其他线程用interrupt方法打断
        System.out.println("尝试获得锁");
        lock.lockInterruptibly();
      } catch (InterruptedException e) {
        e.printStackTrace();
        // 没有获得锁，在等待时被打断了
        return;
      }
      try {
        System.out.println("获取到锁了");
      } finally {
        lock.unlock();
      }
    }, "t1");

    lock.lock();
    t1.start();

    try {
      Thread.sleep(1);
      System.out.println("打断t1");
      t1.interrupt();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

四：锁超时

当tryLock方法里没有传入参数时，默认立刻尝试获得锁：

public class Demo {
  static Lock lock = new ReentrantLock();

  public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
      System.out.println("t1线程启动。。。。。。");
      if (!lock.tryLock()) {
        System.out.println("t1线程获取锁失败，返回");
        return;
      }
      try {
        System.out.println("t1线程获得了锁");
      } finally {
        lock.unlock();
      }
    }, "t1");

    lock.lock();
    System.out.println("主线程获得了锁");
    t1.start();
    try {
      Thread.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      System.out.println("主线程释放锁");
      lock.unlock();
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

但tryLock还有重载方法tryLock(long time, TimeUnit unit)，该方法会等待时间内一直尝试获得锁：

public class Demo {
  static Lock lock = new ReentrantLock();

  public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
      System.out.println("t1线程启动。。。。。。");
      try {
        if (!lock.tryLock(2, TimeUnit.SECONDS)) {
          System.out.println("t1线程获取锁失败，返回");
          return;
        }
      } catch (InterruptedException e) {
        System.out.println("等待被打断");
        e.printStackTrace();
        return;
      }
      try {
        System.out.println("t1线程获得了锁");
      } finally {
        lock.unlock();
      }
    }, "t1");

    lock.lock();
    System.out.println("主线程获得了锁");
    t1.start();
    try {
      Thread.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      System.out.println("主线程释放锁");
      lock.unlock();
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

五：公平锁

公平锁与非公平锁：

• 公平锁的实现就是谁等待时间最长，谁就先获取锁
• 非公平锁就是随机获取的过程，谁运气好，cpu时间片轮询到哪个线程，哪个线程就能获取锁

ReentrantLock默认是不公平，但可以根据需要自行设置是否公平。ReentrantLock构造方法源码如下：

    /**
     * 创建一个ReentrantLock实例
     * 该方法等同于调用ReentrantLock(false)
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * 根据传入的公平策略创建ReentrantLock实例
     * @param fair true为公平策略，false为非公平策略
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ReentrantLock公平锁相对于非公平锁来说，多线程并发情况下的系统吞吐量偏低，因为需要排队等待。所以ReentrantLock公平锁适应于多线程并发不是很高、倾向于先来先到的应用场景。

六：条件变量

ReentrantLock中的条件变量功能，类似于普通synchronized的wait、notify，我们可以使用ReentranLlock锁，配合Condition对象上的await()和signal()或signalAll()方法，来实现线程间协作。与synchronized的wait和notify不同之处在于，ReentrantLock中的条件变量可以有多个，可以实现更精细的控制线程。

在介绍方法的使用之前，先来了解一下Condition是什么。可以把Condition看作是Object监视器的替代品。众所周知，Object有wait()和notify()方法，用于线程间的通信。并且这两个方法只能在synchronized同步块内才可以调用，所有线程的等待和唤醒都需要关联到监视器对象的WaitSet集合。Condition同样可以实现上面的线程通信。不同点在于，synchronized锁对象关联的监视器对象仅有一个，所以等待队列也只有一个。而一个ReentrantLock可以有多个Condition，这样可以根据不同的业务需求，在使用同一个lock锁对象的基础上使用多个等待队列，让不同性质的线程加入到不同的等待队列当中。

AQS当中Condition的实现类是ConditionObject，它是AQS的内部类，所以无法直接实例化。可以配合ReentrantLock来使用。ReentrantLock中有newCondition()的方法，来实例化一个ConditionObject对象，因此可以调用多次newCondition()方法来得到多个等待队列。

使用流程：

• await前需要获得锁
• await 执行后，会释放锁，进入conditionObject等待
• await的线程被唤醒(或打断、或超时)取重新竞争lock锁竞争lock锁成功后，从await后继续执行

示例代码如下：

@Slf4j
public class Demo {

  private static ReentrantLock lock = new ReentrantLock();
  // 等烟休息室
  static Condition cigaretteRoom = lock.newCondition();
  // 等外卖休息室
  static Condition eattingRoom = lock.newCondition();

  static boolean hasCigarette = false;
  static boolean hasTakeout = false;


  public static void main(String[] args) throws InterruptedException {
    // 小南
    new Thread(() -> {
      lock.lock();
      try {
        log.debug("[{}]", hasCigarette);
        while (!hasCigarette) {
          log.debug("没烟，先歇会！");
          try {
            cigaretteRoom.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        log.debug("有烟没？[{}]", hasCigarette);
        if (hasCigarette) {
          log.debug("可以开始干活了");
        }
      } finally {
        lock.unlock();
      }
    }, "小南").start();

    // 小女等外卖
    new Thread(() -> {
      lock.lock();
      try {
        log.debug("外卖送到没？[{}]", hasTakeout);
        while (!hasTakeout) {
          log.debug("没外卖，先歇会！");
          try {
            eattingRoom.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        log.debug("外卖送到没？[{}]", hasTakeout);
        if (hasTakeout) {
          log.debug("可以开始干活了");
        } else {
          log.debug("没干成活...");
        }
      } finally {
        lock.unlock();
      }
    }, "小女").start();

    // 送烟的来了
    Thread.sleep(1000);
    new Thread(() -> {
      lock.lock();
      try {
        hasCigarette = true;
        cigaretteRoom.signal();
      } finally {
        lock.unlock();
      }
    }, "送烟的").start();

    // 送外卖的来了
    Thread.sleep(1000);
    new Thread(() -> {
      lock.lock();
      try {
        hasTakeout = true;
        eattingRoom.signal();
      } finally {
        lock.unlock();
      }
    }, "送外卖的").start();
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85