转载

知否知否，应知ReentrantLock和synchronized的区别

在应用开发中总是会遇到需要对方法进行加锁的场景，java中为我们提供了两种加锁方式，一是synchronized，二是lock方式。那么在实际开发中我们应该选取哪种加锁方式呢

写在前面

通过阅读本篇文章，你将了解到：

  • synchronized和ReentrantLock的不同点、相同点
  • ReentrantLock、synchronized响应中断测试
  • ReentrantLock#tryLock定时获取锁测试
  • ReentrantLock公平锁、非公平锁测试
  • ReentrantLock和synchronized性能测试
  • ReentrantLock应用场景介绍

相同点

  • 互斥 => 同时只有一个线程获取锁
  • 内存可见性 => 对共享变量的修改对另一个线程立即可见
  • 可重入 => 同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞

不同点

锁 synchronize ReentrantLock
加锁释放锁方式 使用者无需关心，自动加锁、释放锁 显式加锁、释放锁，必须调用lock方法获取锁，调用unlock方法释放锁
中断 不可响应中断 可响应中断
超时获取锁 不允许 允许
是否可以实现公平锁 否，默认就为非公平锁 是，通过构造函数指定是否为公平锁，默认为非公平锁，传入true为公平锁
实现方式 JVM级别 API级别

ReentrantLock相比synchronized更灵活一些

ReentrantLock方法测试

ReentrantLock是Lock接口的其中一个实现类，Lock接口中定义的方法有：

  • void lock() => 立即获取锁
  • boolean tryLock() => 立即获取锁
  • boolean tryLock(long time, TimeUnit unit) throws InterruptedException => 在指定时间内获取锁，获得锁返回true，获取不到锁返回false
  • void lockInterruptibly() throws InterruptedException => 获取可中断锁
  • void unlock() => 释放锁
  • Condition newCondition() => 返回绑定到此 Lock 实例的Condition 实例

lock和tryLock方法除了返回值不一样以外，lock获取到的锁是不可响应中断的，而tryLock获取到的锁是可响应中断的。除此以外tryLock(long time, TimeUnit unit)获取到的锁也是可响应中断，即获取锁的方法中只有lock方法获取到的锁是不可以响应中断的

lockInterruptibly响应中断：ReentrantLockLockInterruptiblyTest.java

public class ReentrantLockLockInterruptiblyTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Task());
        thread.start();
        Thread.sleep(3 * 1000);  //执行三秒后中断线程
        thread.interrupt();
    }

    public static class Task implements Runnable {
        Lock lock = new ReentrantLock();

        public Task () {
            new Thread(() -> {
                try {
                    lockMethod();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        @Override
        public void run() {
            try {
                lockMethod();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("End...");
        }

        private void lockMethod() throws InterruptedException {
            lock.lockInterruptibly();
            try {
                //模拟长时间不释放锁
                while (true) {}
            } finally {
                lock.unlock();
            }
        }
    }
}
复制代码

执行结果：

java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
	at com.h2t.study.concurrent.lock.ReentrantLockLockInterruptiblyTest$Task.lockMethod(ReentrantLockLockInterruptiblyTest.java:45)
	at com.h2t.study.concurrent.lock.ReentrantLockLockInterruptiblyTest$Task.run(ReentrantLockLockInterruptiblyTest.java:37)
	at java.lang.Thread.run(Thread.java:748)
End...
复制代码

中断成功

synchronize响应中断：SynchronizedBlock.java

public class SynchronizedBlock {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Task());
        thread.start();
        Thread.sleep(3 * 1000);  //执行三秒后中断线程
        thread.interrupt();
        System.out.println(thread.isInterrupted());
    }

    public static class Task implements Runnable {
        public Task() {
            new Thread() {
                public void run() {
                    f();
                }
            }.start();
        }

        public synchronized void f() {
            while (true) {
            }
        }

        @Override
        public void run() {
            f();
            System.out.println("End");
        }
    }
}
复制代码

控制台永远不会抛出异常、打印出End

对于synchronized来说，如果一个线程在等待锁，调用中断线程的方法，不会生效即不响应中断。而lock可以响应中断

tryLock定时锁：ReentrantLockTryLockTest.java

public class ReentrantLockTryLockTest {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 2; i++) {
            es.execute(new Task(i));
        }
    }

    private static class Task implements Runnable {
        private static Lock lock = new ReentrantLock();

        private int i;

        public Task(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                lockMethod();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //每次只允许一个线程调用
        private void lockMethod() throws InterruptedException {
            long start = System.currentTimeMillis();
            //2s内获得锁
            if (lock.tryLock(2, TimeUnit.SECONDS)) {
                System.out.println(String.format("i = %d 获取到锁，耗时：%d", i, System.currentTimeMillis() - start));
                try {
                    Thread.sleep(1000 * 60 * 1);  //睡眠1分钟
                } finally {
                    lock.unlock();
                }

            } else {
                System.out.println(String.format("i = %d 获取到锁失败，耗时：%d", i, System.currentTimeMillis() - start));
            }
        }
    }
}
复制代码

run方法中调用了加锁的方法，加锁方法中尝试在2s内获得锁 执行结果：

i = 0 获取到锁，耗时：0
i = 1 获取到锁失败，耗时：2001
复制代码

ReentrantLock公平锁与非公平锁：ReentrantLockFairTest.java

public class ReentrantLockFairTest {
    //通过传入true创建一个公平锁
    private static Lock fairLock = new ReentrantLock(true);
    //非公平锁，默认为非公平锁
    private static Lock unfairLock = new ReentrantLock();

    public static void main(String[] args) {
        ExecutorService unfairEs = Executors.newCachedThreadPool();
        ExecutorService fairEs = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            unfairEs.execute(new UnfairTask(i));
            fairEs.execute(new FairTask(i));
        }
    }

    /**
     * 非公平锁任务
     * */
    private static class UnfairTask implements Runnable {
        private int i;

        public UnfairTask(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            unfairLock.lock();
            try {
                System.out.println(String.format("unfairTask i = %d is running", i));
            } finally {
                unfairLock.unlock();
            }
        }
    }

    /**
     * 公平锁任务
     * */
    private static class FairTask implements Runnable {
        private int i;

        public FairTask(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            fairLock.lock();
            try {
                System.out.println(String.format("fairTask i = %d is running", i));
            } finally {
                fairLock.unlock();
            }
        }
    }
}
复制代码

执行结果：

unfairTask i = 0 is running
fairTask i = 0 is running
unfairTask i = 1 is running
fairTask i = 1 is running
unfairTask i = 2 is running
fairTask i = 3 is running
unfairTask i = 3 is running
fairTask i = 2 is running
fairTask i = 4 is running
unfairTask i = 4 is running
复制代码

公平锁先到先得，因此执行顺序是有序的。非公平锁如果后来提交的线程刚好获取释放掉的锁将获得锁先执行，因此结果执行顺序是无序的

synchronized非公平锁：

public class SynchronizedUnfairTest {
    public static void main(String[] args) {
        ExecutorService unfairEs = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            unfairEs.execute(new UnfairTask(i));
        }
    }

    /**
     * 非公平锁任务
     * */
    private static class UnfairTask implements Runnable {
        private int i;

        public UnfairTask(int i) {
            this.i = i;
        }

        @Override
        public synchronized void run() {
            System.out.println(String.format("unfairTask i = %d is running", i));
        }
    }
}
复制代码

执行结果：

unfairTask i = 1 is running
unfairTask i = 0 is running
unfairTask i = 3 is running
unfairTask i = 2 is running
unfairTask i = 4 is running
复制代码

synchronized默认为非公平锁，并且只能是非公平锁，因此执行结果顺序是无序的

性能测试

ReentrantLock加锁任务：ReentrantLockTask.java

public class ReentrantLockTask implements Runnable {
    private int i;

    public ReentrantLockTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        lockMethod();
    }

    ReentrantLock lock = new ReentrantLock();
    private void lockMethod() {
        int sum = 0;
        lock.lock();
        try {
            for (int j = 0; j < 10; j++) {
                sum += j;
            }

        } finally {
            lock.unlock();
        }
    }
}
复制代码

synchronized加锁任务：SynchronizedLockTask.java

public class SynchronizedLockTask implements Runnable {
    private int i;

    public SynchronizedLockTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        lockMethod();
    }

    private synchronized void lockMethod() {
        int sum = 0;

        for (int j = 0; j < 10; j++) {
            sum += j;
        }
    }
}
复制代码

测试类：PerformTest

public class PerformTest {
    public static void main(String[] args) {
        for (int i = 100; i < 1000000000; i = i * 10) {
            reentrantLockTest(i);
            synchronizedLockTest(i);
        }
    }

    /**
     * 循环执行的次数
     * */
    private static void reentrantLockTest(int time) {
        ExecutorService es = Executors.newCachedThreadPool();
        long start = System.currentTimeMillis();
        for (int i = 0; i < time; i++) {
            es.execute(new ReentrantLockTask(i));
        }

        System.out.println(String.format("ReentrantLockTest time = %d Spend %d", time, System.currentTimeMillis() - start));
    }

    private static void synchronizedLockTest(int time) {
        ExecutorService es = Executors.newCachedThreadPool();
        long start = System.currentTimeMillis();
        for (int i = 0; i < time; i++) {
            es.execute(new SynchronizedLockTask(i));
        }

        System.out.println(String.format("SynchronizedLockTest time = %d Spend %d", time, System.currentTimeMillis() - start));
    }
}
复制代码

循环执行任务，统计循环任务的耗时

测试结果：

ReentrantLockTest time = 100 Spend 6
SynchronizedLockTest time = 100 Spend 2
ReentrantLockTest time = 1000 Spend 7
SynchronizedLockTest time = 1000 Spend 14
ReentrantLockTest time = 10000 Spend 42
SynchronizedLockTest time = 10000 Spend 29
ReentrantLockTest time = 100000 Spend 186
SynchronizedLockTest time = 100000 Spend 156
ReentrantLockTest time = 1000000 Spend 1428
SynchronizedLockTest time = 1000000 Spend 1006
ReentrantLockTest time = 10000000 Spend 9716
SynchronizedLockTest time = 10000000 Spend 9791
ReentrantLockTest time = 100000000 Spend 97928
SynchronizedLockTest time = 100000000 Spend 99804
复制代码

synchronized和ReentrantLock性能相差不大，分不出谁好谁不好

synchronized和ReentrantLock之间如何选择

synchronized和ReentrantLock性能差不多， 当且仅当synchronized无法满足的情景下使用ReentrantLock ，因为ReentrantLock需要显式释放锁，同时synchronized是JVM级别的，JVM能对其进行优化，而Reentrant是API级别的不会有任何优化。synchronized无法满足的情景：

  • 定时获取锁
  • 响应中断
  • 需要以公平的方式获取锁

最后附： 示例代码

欢迎 fork 与 star

知否知否，应知ReentrantLock和synchronized的区别
原文  https://juejin.im/post/5ddd2a7c6fb9a0717b5fce02
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 springcloud-demo Redis教程 Spring教程 Git教程 openfire参考指南 Jenkins进阶系列 Java设计模式 HBase教程 java-demo Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Ant教程 java实例教程 Hive教程 SpringCloud ANTLR教程 XStream教程 Elastic-Job-Lite Hazelcast教程 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 注册美区（United States）Google Play 个人开发者账号
  2. 2 中国身份证注册美区 Apple Developer 个人账号完整教程
  3. 3 SaaS MVP：从0到1的功能闭环设计指南
  4. 4 从0到1可执行的“出海型SaaS最佳MVP路径
  5. 5 用 Comet，让你的每一个问题都得到更好的答案
  6. 6 Toolhub — 一个干净实用的在线工具集合
  7. 7 又学一招：Excel 数据对比及 VBA 实现方案
  8. 8 EasyExcel 读取数值精度丢失问题与解决方案
  9. 9 mongodb重命名和创建索引
  10. 10 WordPress 删除尚未附加的图片：优化网站存储空间的实用指南
网站信息
  • 文章总数：82,785 篇
  • 文件总数：210,946 个
  • 标签总数：2,449 个
  • 分类总数：86 个
  • 留言数量：2,584 条
  • 在线人数：609 人
  • 运行天数：4,756天
  • 最后更新：2025年11月04日14点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG