2、高并发编程ReentrantLock

最新推荐文章于 2022-08-02 16:58:40 发布
最新推荐文章于 2022-08-02 16:58:40 发布
阅读量145 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrsun1/article/details/88639975
版权

 

1、尝试锁

在m2中lock.tryLock()是尝试获取锁。可以传入参数，也可以不用传入参数。如果传入参数会引起阻塞，阻塞的时间为传入的参数时间。在时间范围内如果获取到锁返回true，如果没获取到锁返回false。m2中释放锁的时候需要判断是否获取到锁，否则可能会抛出异常。

package com.sunyou.p3;

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

//尝试锁
public class Test2 {
	Lock lock = new ReentrantLock();
	public void m1() {
		lock.lock();
		System.out.println("m1() start");
		try {
			Thread.sleep(5000);
			System.out.println("m1() end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	public void m2() {
		boolean trylock = false;
		try {
			trylock = lock.tryLock(5,TimeUnit.SECONDS);
			if(trylock) {
				System.out.println("try success");
			}else {
				System.out.println("try failure");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			if(trylock) {
				lock.unlock();
			}
		}
	}
	
	public static void main(String[] args) {
		Test2 t = new Test2();
		new Thread(new Runnable() {
			public void run() {
				t.m1();
			}
		}).start();

		new Thread(new Runnable() {
			public void run() {
				t.m2();
			}
		}).start();
	}
}

2、可被打断的锁

加锁的时候可以加为lock.lockInterruptibly()，即可以被打断的锁。如果被打断了会抛出异常。在m1执行过程中，在main中可以直接打断m2，并抛出异常

 

package com.sunyou.p3;

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


//可被打断
public class Test3 {
	Lock lock = new ReentrantLock();
	public void m1() {
		lock.lock();
		System.out.println("m1() start");
		try {
			Thread.sleep(5000);
			System.out.println("m1() end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	public void m2() {
		try {
			lock.lockInterruptibly();
			System.out.println("m2() start");
		} catch (InterruptedException e) {
			System.out.println("m2() interrupt");
			e.printStackTrace();
		}finally {
			try {
				lock.unlock();
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		Test3 t = new Test3();
		new Thread(new Runnable() {
			public void run() {
				t.m1();
			}
		}).start();
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				t.m2();
			}
		});
		t2.start();
		t2.interrupt();
	}
}

阻塞状态：普通阻塞、等待队列、锁池队列

  1. 普通阻塞：sleep(time)，可被打断。调用thread.interrupt()方法，可以打断阻塞状态，抛出异常。
  2. 等待队列：wait()方法被调用，也是一种阻塞状态，只能由notify唤醒。无法打断。
  3. 锁池队列：无法获取锁标记。不是所有的锁池队列都可被打断。

使用ReentrantLock的lock方法，获取锁标记的时候，如果需要阻塞等待锁标记，无法被打断。

使用Reentrantlock的lockInterruptibly方法，获取锁标记的时候，如果需要阻塞等待，可以被打断。

3、公平锁

如果不不公平锁，当某个线程释放锁资源后，不会考虑其他线程等待的时间，下一次哪个线程抢到锁资源就那个线程准备运行。对于公平锁，等待时间最长的线程会优先得到锁资源。使用Reentrantlock的构造函数传入true表示为公平锁。

package com.sunyou.p3;

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

//公平锁
public class Test4 extends Thread{
	Lock lock = new ReentrantLock(true);
	@Override
	public void run() {
		for(int i = 0; i < 5; i++){
			lock.lock();
			System.out.println(Thread.currentThread().getName());
			lock.unlock();
		}
	}
	public static void main(String[] args) {
		Test4 t = new Test4();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
	}
}

4、使用while+notifyAll实现消费者生产者模式

这种方式的notifyAll可能会唤醒本方的线程，下面设置10个线程进行生产，5个线程进行消费。使用一个list集合来装生产消费对象。如果生产满了，会唤醒所有对象包含生产线程。所以不好。

package com.sunyou.p4;

import java.util.LinkedList;

//生产者消费者
public class Test1 {
	private LinkedList<Object> list = new LinkedList<>();
	private static final int MAXSIZE = 10;
	private static int count = 0;

	public int getCount() {
		return count;
	}

	public synchronized void put(Object obj) {
		while (list.size() == MAXSIZE) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		list.add(obj);
		System.out.println(Thread.currentThread().getName()+"生产了烤鸡");
		count++;
		this.notifyAll();
	}

	public synchronized void get() {
		while (list.size() == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		count--;
		System.out.println(Thread.currentThread().getName()+"消费了" + list.removeFirst());
		this.notifyAll();
	}

	public static void main(String[] args) {
		Test1 t = new Test1();
		for (int i = 0; i < 10; i++) {
			new Thread(new Runnable() {
				public void run() {
					while(true)
						t.put("烤鸡");
					}
				},"生产者"+i).start();
		}
		for (int i = 0; i < 5; i++) {
			new Thread(new Runnable() {
				public void run() {
					while (true)
						t.get();
				}
			},"消费者"+i).start();
		}

	}
}

5、使用Condition来指定唤醒对方的线程

package com.sunyou.p4;

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

//生产者消费者模式
public class Test2 {
	private LinkedList<Object> list = new LinkedList<>();
	private static final int MAXSIZE = 10;

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

	public void put(Object obj) {
		lock.lock();
		try {
			while (list.size() == MAXSIZE) {
				producer.await();
			}
			list.add(obj);
			System.out.println(Thread.currentThread().getName() + "生产了" + obj);
			consumer.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void get() {
		lock.lock();
		try {
			while (list.size() == 0) {
				consumer.await();
			}
			System.out.println(Thread.currentThread().getName() + "消费了" + list.removeFirst());
			producer.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public static void main(String[] args) {
		Test2 t = new Test2();
		for (int i = 0; i < 10; i++) {
			new Thread(new Runnable() {
				public void run() {
					while (true)
						t.put("烤鸡");
				}
			}, "生产者" + i).start();
		}
		for (int i = 0; i < 5; i++) {
			new Thread(new Runnable() {
				public void run() {
					while (true)
						t.get();
				}
			}, "消费者" + i).start();
		}
	}
}

6、锁的底层实现

java虚拟机中的同步(synchronized)基于进入和退出管程（monitor）对象实现。同步方法并不是由monitor enter 和 monitor exit指令来实现同步的，而是由方法调用指令读取运行时常量池中方法的ACC_SYNCHRONIZED标志来隐式实现的。

对象内存简图

对象头：存储对象的hashCode、锁信息或分代年龄或GC标志，类型指针指向对象的类元数据，JVM通过这个指针确定该对象是那个类的实例等信息。

实例变量：存放类的属性数据信息，包括父类的属性信息。

当在对象上加锁时，数据是记录在对象头中。当执行synchronized同步方法或同步代码块时，会在对象头中记录锁标记，锁标记指向的是monitor对象的起始地址。每个对象都存在一个monitor与之关联，对象与其monitor之间的关系存在很多实现方式，如monitro可以与对象一起创建销毁或当前线程试图获取对象锁时自动生成，但当一个monitor被某个线程持有后，它便处于锁定状态。在java虚拟机中，monitor是由ObjectMonitor实现的，其中有两个队列，_WaitSet和_EntryList，以及_Ower标记。第一个管理等待队列线程，第二个管理锁池阻塞线程，第三个用于记录当前执行线程。


当多个线程并发访问同一同步代码块时，首先会进入_EntryList，当线程获取锁标记后，monitor中的_Ower记录此线程，并在monitor中的计数器递增加1代表锁定，其他线程在_EntryList中继续阻塞。若执行线程调用wait方法，则monoitor中的计数器执行赋值为0计算，并将_Ower标记赋值为null，代表放弃锁，执行线程进入_WaitSet中阻塞。若执行线程调用notify/notifyAll方法，_WaitSet中的线程被唤醒，进入EntryList中阻塞，等待获取锁标记。若执行线程的同步代码块执行结束，同样会释放锁标记，monitor中的_Ower赋值为null，且计数器赋值为0。

mrsun1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
高并发编程之ReentrantLock
今是而昨非
05-13 242
回顾synchronized public class ReentrantLock1 { public synchronized void test1() { for (int i = 0; i &amp;lt; 10; i++) { System.out.println(i); try { T...
java高并发之ReentrantLock
qq_42618228的博客
07-16 110
我们经常会遇到一个问题，就是lock和synchronized有什么区别？ 我们首先可以通过代码发现，lock是一个接口，而sychornized是一个修饰符 public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws I
Java高并发（六）：ReentrantLock
向日葵班学霸的博客
02-06 232
目录LockReentrantLockReentrantReadWriteLockStampedLockReentrantLockReentrantLock实现原理AQS Lock Java中的Lock是J.U.C中的一个核心组件，J.U.C（java.util.concurrent）是在并发编程中常用的工具类，里面包含了很多在并发场景中使用的组件，比如线程池、阻塞队列、计时器、同步器、并发集合...
多线程和高并发（六） ReentrantLock
mr_zhu_wenxing的博客
05-09 113
多线程和高并发（一） 多线程和高并发（二）| volatile关键字 文章目录多线程和高并发（六） ReentrantLockReentrantReadWriteLock读写锁线程管理线程组创建线程组线程组的基本操作 多线程和高并发（六） ReentrantLock ReentrantReadWriteLock读写锁 synchronized和ReentrantLock都是排他锁（独占锁），同一时间只允许一个线程执行同步代码块，安全但效率低。 ReentranReadWriteLock读写锁是一种改进
java高并发程序设计总结三：JDK并发包之ReentrantLock重入锁
qq_27905183的博客
10-22 1023
为了更好的支持并发程序，jdk内部提供了大量实用的API和框架，重入锁就是一种对同步的扩展ReentrantLock起源在1.5的时候，synchronized关键的性能不是很好，这也是concurrent并发包出现的一种潜在原因，而新出现的ReentrantLock重入锁的性能那时比synchronized好太多，也提供了更加灵活、细粒度的同步操作。（在jdk1.6开始，jdk在synchroni
thread- java高并发编程
最新发布
11-20
Java高并发编程是Java开发中的重要领域，尤其在大型分布式系统和实时响应系统中不可或缺。在多核处理器和海量数据处理需求的驱动下，理解和掌握Java的多线程技术至关重要。"thread- java高并发编程"这个主题包含了对...
实战java高并发编程
08-28
《实战Java高并发编程》是一本深度探讨Java多线程编程和并发控制的书籍，旨在帮助读者从理论到实践全面掌握这一关键领域的知识。在Java编程中，高并发处理是性能优化和系统稳定性的重要组成部分，尤其在大数据处理、...
Java高并发编程，构建并发编程知识体系，提升面试成功率视频教程
09-26
Java高并发编程是Java开发中的核心技能之一，尤其在大型分布式系统中，对并发处理能力的要求更为严格。本教程旨在帮助开发者构建全面的并发编程知识体系，以提高面试成功率和实际工作中的问题解决能力。以下将详细...
java高级并发编程32例
01-22
在Java编程领域，高级并发编程是一项至关重要的技能，特别是在构建高效、可扩展的多线程应用时。"java高级并发编程32例"这个主题涵盖了Java并发机制的深入理解和实践，旨在帮助Java开发者，尤其是那些追求架构师职位...
java高并发编程源码.zip
11-06
Java高并发编程是Java开发中的重要领域，它涉及到如何在多线程环境下高效地管理和调度系统资源，以实现系统的高性能和可伸缩性。在这个"java高并发编程源码.zip"压缩包中，可能包含了一些关于Java并发编程的示例代码...
高并发编程之ReentrantLock工具类讲解
weixin_42146366的博客
02-23 417
一、ReentrantLock介绍 ①、ReentrantLock实现了Lock接口，加锁和解锁都需要显式写出，注意一定要在适当时候unlock。 ②、可重入锁。可重入锁是指同一个线程可以多次获取同一把锁。也是在实际编程中使用频率很高的一个锁，支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞 ③、可中断锁。可中断锁是指线程尝试获取锁的过程中，是否可以响应中断。syn...
03 多线程与高并发 - ReentrantLock 源码解析
刘元雄
08-02 179
03 多线程与高并发 - ReentrantLock 源码解析
Java并发系列[5]----ReentrantLock源码分析
anwupeng2413的博客
02-24 237
在Java5.0之前，协调对共享对象的访问可以使用的机制只有synchronized和volatile。我们知道synchronized关键字实现了内置锁，而volatile关键字保证了多线程的内存可见性。在大多数情况下，这些机制都能很好地完成工作，但却无法实现一些更高级的功能，例如，无法中断一个正在等待获取锁的线程，无法实现限定时间的获取锁机制，无法实现非阻塞结构的加锁规则等。而这些更...
java 并发 获取结果_java高并发系列 - 第31天：获取线程执行结果，这6种方法你都知道？...
weixin_33672838的博客
02-13 199
这是java高并发系列第31篇。环境：jdk1.8。java高并发系列已经学了不少东西了，本篇文章，我们用前面学的知识来实现一个需求：在一个线程中需要获取其他线程的执行结果，能想到几种方式？各有什么优缺点？结合这个需求，我们使用6种方式，来对之前学过的知识点做一个回顾，加深记忆。方式1：Thread的join()方法实现代码：packagecom.itsoku.chat31;importjav...
ReenTrantLock 、synchronized 高并发性能测试
湖人•总冠军
02-28 6318
前言： Synchronized是依赖于JVM实现的，表现为原生语法层面的互斥锁。开发者是无法直接看到相关源码，但是我们可以通过利用javap工具查看生成的class文件信息来分析Synchronize的实现。同步代码块是使用monitorenter和monitorexit指令实现的，同步方法依靠的是方法修饰符上的ACC_SYNCHRONIZED实现。 ReenTr...
ReentrantLock的使用-高并发
清风追梦enjoy的专栏
11-09 1651
1.  * 使用ReentrantLock可以代替Synchronized  * 需注意：必须手动释放锁（重要！！！！）  * 使用synchronized如果遇到异常，jvm会自动释放锁  * 当时lock会手动释放锁，因此经常在finally中进行锁的释放 2.  * 与Synchronized区别：  * 使用ReentrantLock可以进行尝试锁定 tryLock()  * 这样无...
CountDownLatch详解
爱宝贝丶的博客
12-23 150
【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> ...
多线程与高并发系列五（ReentrantLock）
一只小菜鸡的博客
06-30 1968
多线程与高并发系列五（Lock）
多线程高并发系列之ReenTrantLock锁
qq_16607641的博客
12-30 370
ReenTrantLock可以替代synchronized锁，并且比synchronized锁更灵活 synchronized锁是自动上锁、自动解锁，而ReenTrantLock需要手动上锁、手动解锁 synchronized锁在程序运行时，如果抛异常，jvm会自动释放锁，而ReenTrantLock还是得自己手动释放锁，所以，释放锁一般都是写在finally中 ReentrantLock的tr...
Java并发编程实战：ReentrantLock与读写锁详解
第七章深入探讨Java并发编程实践，重点聚焦于锁机制的高级特性，特别是ReentrantLock。ReentrantLock是Java 5.0引入的重要概念，相较于内置的同步机制，它提供了更多的灵活性和控制选项。Lock接口是一个抽象的层次，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值