乐趣区

关于java:ReentrantLock-中的-4-个坑

JDK 1.5 之前 synchronized 的性能是比拟低的,但在 JDK 1.5 中,官网推出一个重量级性能 Lock,一举扭转了 Java 中锁的格局。JDK 1.5 之前当咱们谈到锁时,只能应用内置锁 synchronized,但现在咱们锁的实现又多了一种显式锁 Lock。

后面的文章咱们曾经介绍了 synchronized,详见以下列表:
《synchronized 加锁 this 和 class 的区别!》
《synchronized 优化伎俩之锁收缩机制!》
《synchronized 中的 4 个优化,你晓得几个?》

所以本文咱们重点来看 Lock。

Lock 简介

Lock 是一个顶级接口,它的所有办法如下图所示:

它的子类列表如下:

咱们通常会应用 ReentrantLock 来定义其实例 ,它们之间的关联如下图所示:

PS:Sync 是同步锁的意思,FairSync 是偏心锁,NonfairSync 是非偏心锁。

ReentrantLock 应用

学习任何一项技能都是先从应用开始的,所以咱们也不例外,咱们先来看下 ReentrantLock 的根底应用:

public class LockExample {
    // 创立锁对象
    private final ReentrantLock lock = new ReentrantLock();
    public void method() {
        // 加锁操作
        lock.lock();
        try {// 业务代码......} finally {
            // 开释锁
            lock.unlock();}
    }
}

ReentrantLock 在创立之后,有两个关键性的操作:

  • 加锁操作:lock()
  • 开释锁操作:unlock()

    ReentrantLock 中的坑

    1.ReentrantLock 默认为非偏心锁

    很多人会认为(尤其是老手敌人),ReentrantLock 默认的实现是偏心锁,其实并非如此,ReentrantLock 默认状况下为非偏心锁(这次要是出于性能方面的思考),比方上面这段代码:

    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockExample {
      // 创立锁对象
      private static final ReentrantLock lock = new ReentrantLock();
    
      public static void main(String[] args) {
          // 定义线程工作
          Runnable runnable = new Runnable() {
              @Override
              public void run() {
                  // 加锁
                  lock.lock();
                  try {
                      // 打印执行线程的名字
                      System.out.println("线程:" + Thread.currentThread().getName());
                  } finally {
                      // 开释锁
                      lock.unlock();}
              }
          };
          // 创立多个线程
          for (int i = 0; i < 10; i++) {new Thread(runnable).start();}
      }
    }

    以上程序的执行后果如下:

    从上述执行的后果能够看出,ReentrantLock 默认状况下为非偏心锁。因为线程的名称是依据创立的先后顺序递增的,所以如果是偏心锁,那么线程的执行应该是有序递增的,但从上述的后果能够看出,线程的执行和打印是无序的,这阐明 ReentrantLock 默认状况下为非偏心锁。

想要将 ReentrantLock 设置为偏心锁也很简略,只须要在创立 ReentrantLock 时,设置一个 true 的结构参数就能够了,如下代码所示:

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {// 创立锁对象 ( 偏心锁)
    private static final ReentrantLock lock = new ReentrantLock(true);

    public static void main(String[] args) {
        // 定义线程工作
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 加锁
                lock.lock();
                try {
                    // 打印执行线程的名字
                    System.out.println("线程:" + Thread.currentThread().getName());
                } finally {
                    // 开释锁
                    lock.unlock();}
            }
        };
        // 创立多个线程
        for (int i = 0; i < 10; i++) {new Thread(runnable).start();}
    }
}

以上程序的执行后果如下:

从上述后果能够看出,当咱们显式的给 ReentrantLock 设置了 true 的结构参数之后,ReentrantLock 就变成了偏心锁,线程获取锁的程序也变成有序的了。

其实从 ReentrantLock 的源码咱们也能够看出它到底是偏心锁还是非偏心锁,ReentrantLock 局部源码实现如下:

 public ReentrantLock() {sync = new NonfairSync();
 }
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();}

从上述源码中能够看出,默认状况下 ReentrantLock 会创立一个非偏心锁,如果在创立时显式的设置结构参数的值为 true 时,它就会创立一个偏心锁。

2. 在 finally 中开释锁

应用 ReentrantLock 时肯定要记得开释锁,否则就会导致该锁始终被占用,其余应用该锁的线程则会永恒的期待上来 ,所以咱们在应用 ReentrantLock 时,肯定要在 finally 中开释锁,这样就能够保障锁肯定会被开释。

反例

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    // 创立锁对象
    private static final ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        // 加锁操作
        lock.lock();
        System.out.println("Hello,ReentrantLock.");
        // 此处会报异样, 导致锁不能失常开释
        int number = 1 / 0;
        // 开释锁
        lock.unlock();
        System.out.println("锁开释胜利!");
    }
}

以上程序的执行后果如下:

从上述后果能够看出,当出现异常时锁未被失常开释,这样就会导致其余应用该锁的线程永恒的处于期待状态。

正例

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    // 创立锁对象
    private static final ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        // 加锁操作
        lock.lock();
        try {System.out.println("Hello,ReentrantLock.");
            // 此处会报异样
            int number = 1 / 0;
        } finally {
            // 开释锁
            lock.unlock();
            System.out.println("锁开释胜利!");
        }
    }
}

以上程序的执行后果如下:

从上述后果能够看出,尽管办法中呈现了异常情况,但并不影响 ReentrantLock 锁的开释操作,这样其余应用此锁的线程就能够失常获取并运行了。

3. 锁不能被开释屡次

lock 操作的次数和 unlock 操作的次数必须一一对应,且不能呈现一个锁被开释屡次的状况,因为这样就会导致程序报错。

反例

一次 lock 对应了两次 unlock 操作,导致程序报错并终止执行,示例代码如下:

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    // 创立锁对象
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        // 加锁操作
        lock.lock();
        
        // 第一次开释锁
        try {System.out.println("执行业务 1~");
            // 业务代码 1......
        } finally {
            // 开释锁
            lock.unlock();
            System.out.println("锁释锁");
        }

        // 第二次开释锁
        try {System.out.println("执行业务 2~");
            // 业务代码 2......
        } finally {
            // 开释锁
            lock.unlock();
            System.out.println("锁释锁");
        }
        // 最初的打印操作
        System.out.println("程序执行实现.");
    }
}

以上程序的执行后果如下:

从上述后果能够看出,执行第 2 个 unlock 时,程序报错并终止执行了,导致异样之后的代码都未失常执行。

4.lock 不要放在 try 代码内

在应用 ReentrantLock 时,须要留神不要将加锁操作放在 try 代码中,这样会导致未加锁胜利就执行了开释锁的操作,从而导致程序执行异样。

反例

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    // 创立锁对象
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        try {
            // 此处异样
            int num = 1 / 0;
            // 加锁操作
            lock.lock();} finally {
            // 开释锁
            lock.unlock();
            System.out.println("锁释锁");
        }
        System.out.println("程序执行实现.");
    }
}

以上程序的执行后果如下:

从上述后果能够看出,如果将加锁操作放在 try 代码中,可能会导致两个问题:

  1. 未加锁胜利就执行了开释锁的操作,从而导致了新的异样;
  2. 开释锁的异样会笼罩程序原有的异样,从而减少了排查问题的难度。

总结

本文介绍了 Java 中的显式锁 Lock 及其子类 ReentrantLock 的应用和注意事项,Lock 在 Java 中占据了锁的半壁江山,但在应用时却要留神 4 个问题:

  1. 默认状况下 ReentrantLock 为非偏心锁而非偏心锁;
  2. 加锁次数和开释锁次数肯定要保持一致,否则会导致线程阻塞或程序异样;
  3. 加锁操作肯定要放在 try 代码之前,这样能够防止未加锁胜利又开释锁的异样;
  4. 开释锁肯定要放在 finally 中,否则会导致线程阻塞。

本系列举荐文章

  1. 线程的 4 种创立办法和应用详解!
  2. Java 中用户线程和守护线程区别这么大?
  3. 深刻了解线程池 ThreadPool
  4. 线程池的 7 种创立形式,强烈推荐你用它 …
  5. 池化技术达到有多牛?看了线程和线程池的比照吓我一跳!
  6. 并发中的线程同步与锁
  7. synchronized 加锁 this 和 class 的区别!
  8. volatile 和 synchronized 的区别
  9. 轻量级锁肯定比重量级锁快吗?
  10. 这样终止线程,居然会导致服务宕机?
  11. SimpleDateFormat 线程不平安的 5 种解决方案!
  12. ThreadLocal 不好用?那是你没用对!
  13. ThreadLocal 内存溢出代码演示和起因剖析!
  14. Semaphore 自白:限流器用我就对了!
  15. CountDownLatch:别浪,等人齐再团!
  16. CyclicBarrier:人齐了,司机就能够发车了!
  17. synchronized 优化伎俩之锁收缩机制
  18. synchronized 中的 4 个优化,你晓得几个?

关注公号「Java 中文社群」查看更多有意思、涨常识的 Java 并发文章。

退出移动版