并发编程(四)：Java中的锁 重入锁（ReentrantLock）和 读写锁（ReentrantReadWriteLock）

最新推荐文章于 2023-04-07 22:45:00 发布
最新推荐文章于 2023-04-07 22:45:00 发布
阅读量108 收藏
点赞数
分类专栏： Java分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ssaiwey/article/details/104223939
版权

1. 重入锁（ReentrantLock）：在需要进行同步的代码部分上加上锁定，但不要忘记最后一定要释放锁，不然会造成锁永远无法释放，其他线程永远无法进入。直接上代码：

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by 76706 on 2020/2/8.
 */
public class UseReentrantLock {
    private Lock lock = new ReentrantLock();

    public void method1(){
        try {
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
            Thread.sleep(1000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            lock.unlock();
        }
    }

    public void method2(){
        try {
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
            Thread.sleep(2000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            lock.unlock();
        }
    }

    public static void main(String[] args) {

        final UseReentrantLock ur = new UseReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ur.method1();
                ur.method2();
            }
        }, "t1");

        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上诉代码执行结果：

      当前线程:t1进入method1..
      当前线程:t1退出method1..
      当前线程:t1进入method2..
      当前线程:t1退出method2..

 1.1 在重入锁中（ReentrantLock）需要多线程之间协作工作可以使用新的等待/通知的类，他就是Condition。这个Condition一定是针对具体某一把锁的。也就是在只有在锁的基础之上才会产生Condition。直接上代码：

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by 76706 on 2020/2/8.
 */
public class UseCondition {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void method1(){
        try {
            lock.lock();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
            condition.await();
            System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void method2(){
        try {
            lock.lock();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {

        final UseCondition uc = new UseCondition();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                uc.method1();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                uc.method2();
            }
        }, "t2");
        t1.start();

        t2.start();
    }
}

上述代码执行结果：

        当前线程：t1进入等待状态..
        当前线程：t1释放锁..
        当前线程：t2进入..
        当前线程：t2发出唤醒..
        当前线程：t1继续执行...

1.2 多Condition。可以通过一个Lock产生多个Condition进行多线程之间的交互，非常灵活。可以使得部分需要唤醒的线程唤醒，其他线程则继续等待通知。代码如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by 76706 on 2020/2/8.
 */
public class UseManyCondition {
    private ReentrantLock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();

    public void m1(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
            c1.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m2(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
            c1.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m3(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
            c2.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m4(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
            c1.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m5(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {


        final UseManyCondition umc = new UseManyCondition();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m2();
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m3();
            }
        },"t3");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m4();
            }
        },"t4");
        Thread t5 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m5();
            }
        },"t5");

        t1.start();	// c1
        t2.start();	// c1
        t3.start();	// c2


        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t4.start();	// c1
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t5.start();	// c2

    }
}

上述代码执行结果：

   当前线程：t1进入方法m1等待..
   当前线程：t2进入方法m2等待..
   当前线程：t3进入方法m3等待..
   当前线程：t4唤醒..
   当前线程：t1方法m1继续..
   当前线程：t2方法m2继续..
   当前线程：t5唤醒..
   当前线程：t3方法m3继续.. 

 2. 读写锁（ReentrantReadWriteLock），其核心就是实现读写分离的suo。在高并发访问下，尤其读多写少的情况下，性能要远远高于重入锁。synchronized  ReentrantLock 都是同一时间内只能有一个线程访问被锁定的代码，那么读写锁则不同，其本质是两个锁，即 读 锁 ，写  锁，在读锁情况下，多个线程可以并发访问，但是在写锁时只能一个一个顺序访问。读读共享，写写互斥，读写互斥。代码如下：（ps:大家可以把代码放到ide里面执行观察效果）

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class UseReentrantReadWriteLock {

	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
	private ReadLock readLock = rwLock.readLock();
	private WriteLock writeLock = rwLock.writeLock();
	
	public void read(){
		try {
			readLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}
	
	public void write(){
		try {
			writeLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t4");		
		
//		t1.start();
//		t2.start();
		
//		t1.start(); // R 
//		t3.start(); // W
		
		t3.start();
		t4.start();
		
		
	}
}

 

退役未退休的码农
关注
专栏目录
「java并发编程」ReentrantLock可重入读写锁
uuqaz的博客
05-15 562
一、ReentrantLock可重入锁 二、ReentrantReadWriteLock读写锁 三、读锁之间不互斥 一、ReentrantLock可重入锁 可重入锁ReentrantLock 是一个互斥锁，即同一时间只有一个线程能够获取锁定资源，执行锁定范围内的代码。这一点与synchronized 关键字十分相似。其基本用法代码如下： Locklock=newReentrantLock();//实例化锁 //lock.lock();//上锁 booleanlocked...
阿里面试失败后，一气之下我图解了Java中18把锁
热门推荐
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
java 锁之读写锁 ReentrantReadWriterLock 详解
weixin_44245828的博客
11-02 270
先抛问题，java Lock 有了 ReentrantLock，为什么还需要 ReentrantReadWriteLock ？ ReentrantLock 可以解决 Lock 进行同步控制的需求，但在多个线程只需读数据的时候，ReentrantLock 也让线程进行排队控制，影响性能。ReentrantReadWriteLock 应运而生。 ReentrantReadWriteLock 维护了一个 读写锁内部类ReentrantReadWriteLock.ReadLock、ReentrantReadWr
java读写锁ReentrantReadWriteLock
梦里蓝天
04-07 346
在多线程的应用场景中，解决线程安全问题使用ReentrantLock就可以()，但是ReentrantLock是独占锁，同时只有一个线程可以获取该锁，而在写少读多的场景，显然ReentrantLock满足不了这个需求，所以ReentrantReadWriteLock应运而生。ReentrantReadWriteLock采用读写分离的策略，允许多个线程可以同时获取读锁。
java并发读取 调用 加锁 解锁_java并发之读写锁ReentrantReadWriteLock的使用
weixin_42509796的博客
02-28 160
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能...
Java并发学习（六）显式锁的实现，重入锁ReentrantLock、读写锁ReentrantReadWriteLock
cai13070139328的博客
08-17 172
上次对于显示锁和队列同步器的学习已经提到，我们可以使用Java提供的队列同步器AQS实现自定义的同步组件。同样，Java自身也为我们提供了很多可用的锁(或同步组件)，如重入锁ReentrantLock和读写锁ReentrantReadWriteLock等，它们也是通过AQS实现的，并且继承了Lock接口。 与内置锁synchronized不同，Lock接口提供了一种无条件的、可轮询的、定时的以及...
Java多线程问题--ReentrantReardWriteLock类的用法
樊先知樊先知的博客
01-24 200
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！ 代码地址：https://github.com/xianzhixianzhixian/thread.git ReentrantReardWriteLock类的优势和用法 1、ReentrantLock类中提供了lock.lock()和lock.unlock()来实现获得对象锁和释放对象锁。但是我们可以考虑这样一个问题，当多个...
Java并发编程之重入锁与读写锁
08-29
Java并发编程之重入锁与读写锁 在 Java 并发编程中，重入锁和读写锁是两个非常重要的概念。...重入锁和读写锁是 Java 并发编程中非常重要的概念，正确地使用它们可以提高并发性能，避免死锁和其他并发问题。
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
9. **可读写的锁**：虽然ReentrantLock主要关注互斥锁，但Java并发包中还有ReentrantReadWriteLock，它提供了读写锁，允许多个读取线程同时访问资源，而写入操作仍然保持互斥。 总结来说，ReentrantLock提供了比...
java 线程锁 可重入锁 可中断锁 公平锁 非公平锁ReentrantLock synchronized,条件Condition,读写锁 ReentrantReadWriteLock写写互斥读读共享
银河系天城知识宝库_技术专家蒋浩宇
05-06 334
目录 介绍 synchronized 修饰方块执行顺序 lock 提供了更加灵活的方式实现 lock 接口 这玩意应用场景 加锁和释放锁示例 lock普通获取锁 tryLock() 中断锁 newCondition() Lock接口的实现类：可重入锁 ReentrantLock 主要方法 ReentrantLock 锁示例 lock示例 结果日志 tryLock 锁 结果 lock.tryLock(1000,TimeUnit.SECONDS) lockInterrupt.
java-ReentrantLock读写锁
深未来技术
02-21 108
1、读写锁，一个资源能被多个读者访问，或被一个写者访问，两者不能同时进行。 2、 public interface ReadWriteLock{   lock readLock();   lock writeLock(); } 3、ReentrantReadWriteLock为2个锁提供了可重进入的加锁语义。与ReentrantLock相同，ReentrantReadWriteLock...
CopyOnWriteArrayList读写锁
bjxiaxueliang的CODING技术小馆
04-10 1930
转自： http://ifeve.com/java-copy-on-write/Copy-On-Write是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnW
Java 并发小记
cauchy8389的专栏
03-15 186
首先，讲讲相位器Phaser 很多人不理解，其实相位器是有phase这个概念的，register增加一个part,多个register动态申请了part。当一次所有register的parts都到达时，相位phase自动加一 看如下代码： public class PhaserDemo { public static void main(String[] args) { ...
JAVA中的ReentrantLock和ReentrantReadWriteLock锁简单使用
madman
01-20 7190
ReentrantLock的作用和synchronize是一样的，都是实现锁的功能，但是ReentrantLock需要手写代码对锁进行获取和释放(一定要在finally里面释放)，要不然就永远死锁了，ReentrantLock也可以用来做线程之间的挂起和通知，synchronize一般是使用object的wait和notify来实现，ReentrantLock使用Condition来实现线程之间的...
java.util.concurrent.locks.ReentrantReadWriteLock读写锁源码解析
sunpy
09-08 1427
1.什么是读写锁
JSP学生学籍管理系统设计与实现(源代码+论文+开题报告+外文翻译+答辩PPT).zip
09-21
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
省市区数据，完成三级联动，选择地区
09-21
省市区数据，完成三级联动，选择地区
机械原理课程设计网球自动捡球机.doc
最新发布
09-21
机械原理课程设计网球自动捡球机.doc
2024秋招华为笔试题大全-仅供参考具体需要根据实际修改
09-21
2024秋招华为笔试题大全-仅供参考具体需要根据实际修改
Java并发编程：深入理解锁机制与JUC包
本文将深入探讨Java中的两种主要锁类型：同步锁和JUC（Java Util Concurrency）包中的锁。 **同步锁（Synchronized Locks）** 同步锁源于Java 1.0版本，通过`synchronized`关键字实现，它为每个对象提供了唯一的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值