Java 多线程并发编程之互斥锁 Reentrant Lock

最新推荐文章于 2024-04-17 17:42:30 发布
最新推荐文章于 2024-04-17 17:42:30 发布
阅读量862 收藏 2
点赞数
分类专栏： 多线程

Java 中的锁通常分为两种：

  • 通过关键字 synchronized 获取的锁，我们称为同步锁，上一篇有介绍到：Java 多线程并发编程 Synchronized 关键字。
  • java.util.concurrent（JUC）包里的锁，如通过继承接口 Lock 而实现的 ReentrantLock（互斥锁），继承 ReadWriteLock 实现的 ReentrantReadWriteLock（读写锁）。

本篇主要介绍 ReentrantLock（互斥锁）。

ReentrantLock（互斥锁）

ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃。

ReentrantLock 互斥锁是可重入锁，即某一线程可多次获得该锁。

公平锁 and 非公平锁

    public ReentrantLock() {
        sync = new NonfairSync();
    }

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

由 ReentrantLock 的构造函数可见，在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁，而默认会构造一个非公平锁。

公平锁与非公平锁区别在于竞争锁时的有序与否。公平锁可确保有序性（FIFO 队列），非公平锁不能确保有序性（即使也有 FIFO 队列）。

然而，公平是要付出代价的，公平锁比非公平锁要耗性能，所以在非必须确保公平的条件下，一般使用非公平锁可提高吞吐率。所以 ReentrantLock 默认的构造函数也是“不公平”的。

一般使用

DEMO1：

public class Test {

    private static class Counter {

        private ReentrantLock mReentrantLock = new ReentrantLock();

        public void count() {
            mReentrantLock.lock();
            try {
                for (int i = 0; i < 6; i++) {
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                }
            } finally {
	            // 必须在 finally 释放锁
                mReentrantLock.unlock();
            }
        }
    }

    private static class MyThread extends Thread {

        private Counter mCounter;

        public MyThread(Counter counter) {
            mCounter = counter;
        }

        @Override
        public void run() {
            super.run();
            mCounter.count();
        }
    }

    public static void main(String[] var0) {
        Counter counter = new Counter();
        // 注：myThread1 和 myThread2 是调用同一个对象 counter
        MyThread myThread1 = new MyThread(counter);
        MyThread myThread2 = new MyThread(counter);
        myThread1.start();
        myThread2.start();
    }
}

DEMO1 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1， i = 0
Thread-1， i = 1
Thread-1， i = 2
Thread-1， i = 3
Thread-1， i = 4
Thread-1， i = 5

DEMO1 仅使用了 ReentrantLock 的 lock 和 unlock 来提现一般锁的特性，确保线程的有序执行。此种场景 synchronized 也适用。

锁的作用域

DEMO2：

public class Test {

    private static class Counter {

        private ReentrantLock mReentrantLock = new ReentrantLock();

        public void count() {
            for (int i = 0; i < 6; i++) {
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                try{
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
	                // 必须在 finally 释放锁
                    mReentrantLock.unlock();
                }
            }
        }

        public void doOtherThing(){
            for (int i = 0; i < 6; i++) {
                // 模拟耗时，突出线程是否阻塞
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
            }
        }
    }

    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        }).start();
    }
}

DEMO2 输出：

Thread-0， i = 0
Thread-1 doOtherThing， i = 0
Thread-0， i = 1
Thread-1 doOtherThing， i = 1
Thread-0， i = 2
Thread-1 doOtherThing， i = 2
Thread-0， i = 3
Thread-1 doOtherThing， i = 3
Thread-0， i = 4
Thread-1 doOtherThing， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 5

DEMO3:

public class Test {

    private static class Counter {

        private ReentrantLock mReentrantLock = new ReentrantLock();

        public void count() {
            for (int i = 0; i < 6; i++) {
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                try{
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 必须在 finally 释放锁
                    mReentrantLock.unlock();
                }
            }
        }

        public void doOtherThing(){
            mReentrantLock.lock();
            try{
                for (int i = 0; i < 6; i++) {
                    // 模拟耗时，突出线程是否阻塞
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
                }
            }finally {
                mReentrantLock.unlock();
            }

        }
    }

    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        }).start();
    }
}

DEMO3 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 0
Thread-1 doOtherThing， i = 1
Thread-1 doOtherThing， i = 2
Thread-1 doOtherThing， i = 3
Thread-1 doOtherThing， i = 4
Thread-1 doOtherThing， i = 5

结合 DEMO2 和 DEMO3 输出可见，锁的作用域在于 mReentrantLock，因为所来自于 mReentrantLock。

可终止等待

DEMO4：

public class Test {

    static final int TIMEOUT = 300;

    private static class Counter {

        private ReentrantLock mReentrantLock = new ReentrantLock();

        public void count() {
            try{
                //lock() 不可中断
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                for (int i = 0; i < 6; i++) {
                    long startTime = System.currentTimeMillis();
                    while (true) {
                        if (System.currentTimeMillis() - startTime > 100)
                            break;
                    }
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                }
            } finally {
                // 必须在 finally 释放锁
                mReentrantLock.unlock();
            }
        }

        public void doOtherThing(){
            try{
                //lockInterruptibly() 可中断，若线程没有中断，则获取锁
                mReentrantLock.lockInterruptibly();
                for (int i = 0; i < 6; i++) {
                    // 模拟耗时，突出线程是否阻塞
                    long startTime = System.currentTimeMillis();
                    while (true) {
                        if (System.currentTimeMillis() - startTime > 100)
                            break;
                    }
                    System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 中断 ");
            }finally {
                // 若当前线程持有锁，则释放
                if(mReentrantLock.isHeldByCurrentThread()){
                    mReentrantLock.unlock();
                }
            }
        }
    }

    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        });
        thread2.start();
        long start = System.currentTimeMillis();
        while (true){
            if (System.currentTimeMillis() - start > TIMEOUT) {
                // 若线程还在运行，尝试中断
                if(thread2.isAlive()){
                    System.out.println(" 不等了，尝试中断 ");
                    thread2.interrupt();
                }
                break;
            }
        }
    }
}

DEMO4 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
不等了，尝试中断
Thread-1 中断
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5

线程 thread2 等待 300ms 后 timeout，中断等待成功。

若把 TIMEOUT 改成 3000ms，输出结果：（正常运行）

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1 doOtherThing， i = 0
Thread-1 doOtherThing， i = 1
Thread-1 doOtherThing， i = 2
Thread-1 doOtherThing， i = 3
Thread-1 doOtherThing， i = 4
Thread-1 doOtherThing， i = 5

定时锁

DEMO5：

public class Test {

    static final int TIMEOUT = 3000;

    private static class Counter {

        private ReentrantLock mReentrantLock = new ReentrantLock();

        public void count() {
            try{
                //lock() 不可中断
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                for (int i = 0; i < 6; i++) {
                    long startTime = System.currentTimeMillis();
                    while (true) {
                        if (System.currentTimeMillis() - startTime > 100)
                            break;
                    }
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                }
            } finally {
                // 必须在 finally 释放锁
                mReentrantLock.unlock();
            }
        }

        public void doOtherThing(){
            try{
                //tryLock(long timeout, TimeUnit unit) 尝试获得锁
                boolean isLock = mReentrantLock.tryLock(300, TimeUnit.MILLISECONDS);
                System.out.println(Thread.currentThread().getName() + " isLock:" + isLock);
                if(isLock){
                    for (int i = 0; i < 6; i++) {
                        // 模拟耗时，突出线程是否阻塞
                        long startTime = System.currentTimeMillis();
                        while (true) {
                            if (System.currentTimeMillis() - startTime > 100)
                                break;
                        }
                        System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
                    }
                }else{
                    System.out.println(Thread.currentThread().getName() + " timeout");
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 中断 ");
            }finally {
                // 若当前线程持有锁，则释放
                if(mReentrantLock.isHeldByCurrentThread()){
                    mReentrantLock.unlock();
                }
            }
        }
    }

    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        });
        thread2.start();
    }
}

DEMO5 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-1 isLock:false
Thread-1 timeout
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5

tryLock() 尝试获得锁，tryLock(long timeout, TimeUnit unit) 在给定的 timeout 时间内尝试获得锁，若超时，则不带锁往下走，所以必须加以判断。

ReentrantLock or synchronized

ReentrantLock 、synchronized 之间如何选择？

ReentrantLock 在性能上 比 synchronized 更胜一筹。

ReentrantLock 需格外小心，因为需要显式释放锁，lock() 后记得 unlock()，而且必须在 finally 里面，否则容易造成死锁。

synchronized 隐式自动释放锁，使用方便。

ReentrantLock 扩展性好，可中断锁，定时锁，自由控制。

synchronized 一但进入阻塞等待，则无法中断等待。

逐个温度
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程并发编程(互斥锁Reentrant Lock)
08-30
Java 多线程并发编程（互斥锁 Reentrant Lock） ReentrantLock 是 Java 中的一种高级锁机制，属于互斥锁的一种，能够在多线程并发编程中发挥重要作用。下面将详细介绍 ReentrantLock 的概念、特点、用法和优缺点。 ...
Java并发之ReentrantLock锁
墨玉浮白的博客
04-26 788
简介 一种可重入的互斥锁，经由Java5引入，支持一个线程对资源的重复加锁。它和synchronized语句和方法访问的隐式监视器锁，有相同的基本行为和语义，但是功能更强大。 一、Lock接口 锁对象，在java中锁是控制多个线程访问共享资源的方式，一个锁能防止多个线程同时访问共享资源（但有的锁就允许多个线程并发访问，如读写锁）。在Lock接口出现之前，是靠synchronized关键字来实现锁的...
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
一只文森特
04-25 1609
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
java学习——互斥锁
最新发布
m0_73245690的博客
04-17 286
1.java语言里，引入了对象互斥锁的概念，来保证共享数据操作的完整性。2.每个对象都对应于一个可称为互斥锁的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。3.关键字synchronized来与对象的互斥锁联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。4.同步的局限性：导致程序的执行效率要降低。5.同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）。6.同步方法（静态的）的锁是当前类本身。
[Java多线程-基础] 避免线程死锁问题(ReentrantLock的使用)
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
04-30 1080
ReentrantLock 的设计初衷是为了提供一种比 synchronized 更加灵活和可控的锁机制。与 synchronized 相比，ReentrantLock 提供了更多的功能，如可重入性、公平锁和中断锁等，使得它在某些场景下更适用。具体来说，ReentrantLock 可以通过以下方式提供更好的控制和灵活性：1. 可重入性：允许线程多次获得同一个锁，避免死锁情况的发生。2. 公平锁：可以实现公平的锁分配机制，避免某些线程长期无法获取到锁而产生的饥饿问题。
多线程的同步与互斥（互斥锁、读写锁、自旋锁、条件变量、信号量）
fengruoying93的专栏
12-17 883
转自：https://blog.csdn.net/daaikuaichuan/article/details/82950711 https://blog.csdn.net/zryoo_k/article/details/88559142 一、同步与互斥的概念 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定...
Java中的互斥锁介绍
一名Java语言狂热分子。
05-03 4288
互斥锁是一种广泛应用于多线程编程中的并发控制机制。在Java中，互斥锁有很多不同的实现方式，在本文中我们将介绍Java中常见的几种互斥锁实现方式，并讲解它们的用法、原理和代码案例。
Java并发编程实战之互斥锁.pptx
11-13
“原子性”的本质是什么？其实不是不可分割，不可分割只是外在表现，其本质是多个资源间有一致...（其实没有共享变量，也不会存在并发问题），所以说如果我们能够保证对共享变量的修改是互斥的，那么就能保证原子性了。
Python多线程编程（四）：使用Lock互斥锁
09-22
在Python的多线程编程中，互斥锁（Mutex，也称锁）是一种重要的同步机制，用于解决多个线程并发访问共享资源时可能出现的数据不一致问题。本文将深入探讨互斥锁的概念、如何使用以及其在解决线程不安全问题中的作用...
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
Java多线程 ReentrantLock互斥锁详解
08-25
ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制可以避免死锁的出现。 ReentrantLock...
3.线程间同步和通信之互斥锁（动态）
08-24
3.线程间同步和通信之互斥锁（动态），通过按键和LED的组合学习互斥锁的功能，理解互斥锁
进程/线程互斥锁与同步锁
Yietong的博客
08-11 450
并发编程让我们能够充分利用IO资源, 但是当多个进程使用同一分述句资源的时候就会引发数据安全或者数据混乱问题.
一文看懂临界区、互斥锁、同步锁、临界区、信号量、自旋锁等名词！
xmt1139057136的专栏
02-20 5241
点击上方“业余草”，选择“置顶公众号” 第一时间获取技术干货和业界资讯！ 关于线程安全的专有名词有一大堆。你们突然之间问我这个名词是什么意思，那个名词是什么意思我还真不一定能给你准确的回答。这还别说一门语言一堆名词。其实有些名词叫法不同，实际上就是一个意思。 A 语言有这个名词，B 语言就起另外一个名词。不能大胆的雷同，所以就改变一个叫法，其本质还是一样的。 为了减少大家在...
java 多线程（四）—— 线程同步/互斥=队列+锁
qq_44886213的博客
11-21 1685
同步就是多个线程同时访问一个资源。那么如何实现？队列+锁。想要访问同一资源的线程排成一个队列，按照排队的顺序访问。访问的时候加上一个锁（参考卫生巾排队+锁门），访问完释放锁。
Java并发编程实战之互斥锁
C.
10-24 2049
一谈到互斥，我们很自然就会想到了锁。首先我们把一段需要互斥执行的代码称为临界区。线程在进入临界区之前，首先尝试加锁 `lock()`，如果成功，则进入临界区，此时我们称这个线程持有锁；否则呢就等待，直到持有锁的线程解锁；持有锁的线程执行完临界区的代码后，执行解锁 `unlock()`。
Java中线程同步锁和互斥锁有啥区别？看完你还是一脸懵逼？
weixin_30569153的博客
06-14 809
首先不要钻概念牛角尖，这样没意义。 也许java语法层面包装成了sycnchronized或者明确的XXXLock，但是底层都是一样的。无非就是哪种写起来方便而已。 锁就是锁而已，避免多个线程对同一个共享的数据并发修改带来的数据混乱。 锁要解决的大概就只有这4个问题： “谁拿到了锁“这个信息存哪里（可以是当前class，当前instance的markword...
Java 中线程同步锁和互斥锁
liuwg1226的专栏
08-24 2584
一 概述 1.1 互斥 所谓互斥，就是不同线程，通过竞争进入临界区（共享的数据和硬件资源），为了防止访问冲突，在有限的时间内只允许其中之一独占性的使用共享资源。如不允许同时写。 1.2 同步 同步关系则是多个线程彼此合作，通过一定的逻辑关系来共同完成一个任务。一般来说，同步关系中往往包含互斥，同时，对临界区的资源会按照某种逻辑顺序进行访问。如先生产后使用。 1.3 两者区别 总的来说，两者的区别就是：互斥是通过竞争对资源的独占使用，彼此之间不需要知道对方的存在，执行顺序是一个乱序。同步是协调多个相互关联线程
JAVA中的互斥锁
weixin_43709238的博客
01-04 1300
无

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值