Lock和Condition

最新推荐文章于 2023-03-24 15:12:04 发布
最新推荐文章于 2023-03-24 15:12:04 发布
阅读量214 收藏
点赞数
分类专栏： 多线程 Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guzizai2007/article/details/84420588
版权

1、jdk1.5之前用synchornized和voatile来控制共享对象的并发访问，jdk5.0提供了ReentrantLock。

2、Lock和ReentrantLock：

 

Lock接口里定义了一些抽象的锁操作，有无条件、可轮询、定时、可中断的锁获取操作，ReentrantLock实现了Lock接口，获得ReetrantLock的锁与进入synchronized代码块有相同的内存语义，释放ReentrantLock锁和退出sychronized代码块有相同的内存语义。

 

从上面可以看出，Lock提供了不同形式获取锁方式，而之前通过synchronied修饰代码块的时候，如果有一个线程已经获取对象锁，其他线程访问共享对象的时候就必须无限等待，等待当前线程释放对象锁后再去进行竞争，不能中断那些等待获取锁的线程，而Lock提供了一些其他方法，比如tryLock()：如果当前锁可用则获取并返回true，如果不可用则返回false。在方法前加上while(true)就可以实现轮询获取锁。

package com.sxit.test;

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

/**
 * @功能：tryLock使用
 * @作者: smile
 * @时间：2013-4-18 下午4:03:18
 * @版本：1.0
 */
public class TryLockDemo {

	// 锁
	private final Lock lock = new ReentrantLock();

	public void take() {
			if (lock.tryLock()) {
				try {
					System.out.println("take获取到锁...");
				} catch (Exception e) {
					e.printStackTrace();
				} finally{
					lock.unlock();
				}
			}else{
				System.out.println("take没有获取到锁...");
			}
	}

	public void put() {
			if (lock.tryLock()) {
				try {
					System.out.println("put获取到锁...");
				} catch (Exception e) {
					e.printStackTrace();
				} finally{
					lock.unlock();
				}
			}else{
				System.out.println("put没有获取到锁...");
			}
	}

	public static void main(String[] args) {

		TryLockDemo t = new TryLockDemo();
		Take take = new Take(t);
		Put put = new Put(t);
		Thread t1 = new Thread(take);
		Thread t2 = new Thread(put);

		t1.start();
		t2.start();
	}
}

class Take implements Runnable {

	private TryLockDemo t;

	public Take(TryLockDemo t) {
		this.t = t;
	}

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			t.take();
		}
	}
}

class Put implements Runnable {

	private TryLockDemo t;

	public Put(TryLockDemo t) {
		this.t = t;
	}

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			t.put();
		}
	}
}

 

 

通过使用tryLock方法就可以让那些等待线程可以不用再无限期等待，可以继续轮询获取锁或者做其他操作。

tryLock还有一个指定时间获取锁的方法，在指定时间内如果锁可用则返回，不可用则线程处于休眠状态。

package com.sxit.test;

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

/**
 * @功能：tryLock使用
 * @作者: smile
 * @时间：2013-4-18 下午4:03:18
 * @版本：1.0
 */
public class TryLockDemo {

	// 锁
	private final Lock lock = new ReentrantLock();

	public void take() throws Exception {
			if (lock.tryLock(100,TimeUnit.NANOSECONDS)) {
				try {
					System.out.println("take获取到锁...");
				} catch (Exception e) {
					e.printStackTrace();
				} finally{
					lock.unlock();
				}
			}else{
				System.out.println("take 100纳秒内没有获取到锁...");
			}
	}

	public void put() throws Exception {
			if (lock.tryLock(100,TimeUnit.NANOSECONDS)) {
				try {
					System.out.println("put获取到锁...");
				} catch (Exception e) {
					e.printStackTrace();
				} finally{
					lock.unlock();
				}
			}else{
				System.out.println("put 100纳秒内没有获取到锁...");
			}
	}

	public static void main(String[] args) {

		TryLockDemo t = new TryLockDemo();
		Take take = new Take(t);
		Put put = new Put(t);
		Thread t1 = new Thread(take);
		Thread t2 = new Thread(put);

		t1.start();
		t2.start();
	}
}

class Take implements Runnable {

	private TryLockDemo t;

	public Take(TryLockDemo t) {
		this.t = t;
	}

	@Override
	public void run() {
		while (true) {
			try {
				t.take();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

class Put implements Runnable {

	private TryLockDemo t;

	public Put(TryLockDemo t) {
		this.t = t;
	}

	@Override
	public void run() {
		while (true) {
			try {
				t.put();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

 还有一种是lockInterruptibly()：可中断的锁获取，当线程在获取锁的时候，如果有其他线程调用该线程的interrupt方法中断线程，这时不会再去尝试获取锁，而会抛出一个InterruptedException异常。而正常的lock()方法不允许中断线程，即使调用了interrupt()方法还是会继续尝试获取锁，最后获取到锁后再把线程设置为interrupt状态，然后再中断。 而且使用lockInterruptibly获取锁的时候，如果线程被中断了，会抛出异常，并且会把线程的中断状态移除。

package com.sxit.test;

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

/**
 * @功能：lockInterruptibly使用
 * @作者: smile
 * @时间：2013-4-18 下午4:03:18
 * @版本：1.0
 */
public class TryLockDemo {

	// 锁
	private final Lock lock = new ReentrantLock();

	public void interrupt() {
		try {
			lock.lockInterruptibly();
			System.out.println("打印一下");
			//中断前状态
			System.out.println("中断前状态:"+Thread.currentThread().isInterrupted());
			//中断当前线程
			Thread.currentThread().interrupt();
			//中断后状态
			System.out.println("中断后状态:"+Thread.currentThread().isInterrupted());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			//中断最后状态
			System.out.println("中断最后状态:"+Thread.currentThread().isInterrupted());
			lock.unlock();
		}
	}

	public static void main(String[] args) {

		TryLockDemo t = new TryLockDemo();
		Iterrupt i = new Iterrupt(t);
		Thread t1 = new Thread(i);
		
		t1.start();
		
	}
}


class Iterrupt implements Runnable {

	private TryLockDemo t;

	public Iterrupt(TryLockDemo t) {
		this.t = t;
	}

	@Override
	public void run() {
		while (true) {
			try {
				t.interrupt();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

 

还有一个方法是newCondition（），返回一个Condition实例。这个方法时返回一个绑定这个Lock实例的条件对象实例。

 

之前使用synchronized的时候，比如生产者和消费者模型中有take和put两个操作，当队列为空时会调用list.wait()，当队列满的时候也会调用list.wait()，就是把当前线程加入到list对象的锁等待池中，而当队列不为空或者队列不是满的时候我们会调用notifyAll或者notify，比如take中调用notify时，它会从锁等待池中随机选一个线程让它进入可运行状态，等待锁释放后去竞争锁，但是这里就有一个问题，其实我们这里需要唤醒的是take线程，但是使用notify的时候随机性很强，很有可能他唤醒的是一个put线程或者别的线程，当然可以使用notifyAll，他会唤醒对象锁池中的所有线程，但是等锁释放后，还是只有一个锁能够竞争到资源进入运行状态，所以这样不能明确快速的指定具体要唤醒的线程。

 

现在jdk5.0提供了Condition，通过lock.newCondition()可以获得绑定当前锁的条件对象，每个条件对象都维护相对于自己这个条件的线程等待池，比如队列非空，可以创建一个Condition not_empty = lock.newCondition();  当take的时候如果队列为空，则not_empty.await()，这样当前线程由这个条件对象来维护，当队列非空的时候就可以通过调用not_empty.sigal()来唤醒那些需要取元素的线程。这样就能把各种线程在不同条件下进行细致分类，灵活操作。不用像之前那样直接用个notifyAll，使用notifyAll把不同条件需求的线程全绑定在一个队列中，一个条件满足就需要唤醒全部线程，然后相互竞争锁，既不精确性能也差。

 

一个简单的生产者和消费者模型实例：

package com.sxit.test;

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

/**
 * @功能：使用Lock Conditon
 * @作者: smile
 * @时间：2013-4-18 下午5:18:07
 * @版本：1.0
 */
public class Test05 {
	
	public static Lock lock = new ReentrantLock();;
	// 容器已满  綁定product線程
	public static Condition full = lock.newCondition();
	// 容器为空  綁定consumer線程
	public static Condition empty = lock.newCondition();

	public static void main(String[] args) {
		List list = new ArrayList(12);
		Product product = new Product(list, 10);
		Consumer consumer = new Consumer(list, 0);
		
		Thread t1 = new Thread(product);
		Thread t2 = new Thread(consumer);
		
		t1.start();
		t2.start();
	}
	
	// 生产
	static class Product implements Runnable {

		private List list;
		private int maxCount;

		public Product(List list, int maxCount) {
			super();
			this.list = list;
			this.maxCount = maxCount;
		}

		@Override
		public void run() {
			while(true){
				if (lock.tryLock()) {
					try {
						if (getSize() >= maxCount) {
							System.out.println("容器已滿，product線程加入池中...");
							full.await();
						}
						System.out.println("開始生產....");
						list.add(new Object());
						//喚醒消費者線程
						empty.signal();
					} catch (InterruptedException e) {
						e.printStackTrace();
					} finally {
						lock.unlock();
					}
				} else {
					System.out.println("未获取生产资格...");
				}
			}
		}

		public int getSize() {
			return list.size();
		}
	}

	// 消费
	static class Consumer implements Runnable {

		private List list;
		private int minCount;

		public Consumer(List list, int minCount) {
			super();
			this.list = list;
			this.minCount = minCount;
		}

		@Override
		public void run() {
			while(true){
				if (lock.tryLock()) {
					try {
						if (getSize() <= minCount) {
							System.out.println("容器已空，consumer線程加入池中...");
							empty.await();
						}
						System.out.println("開始消費....");
						list.remove(0);
						//喚醒生產者線程
						full.signal();
					} catch (InterruptedException e) {
						e.printStackTrace();
					} finally {
						lock.unlock();
					}
				} else {
					System.out.println("未获取消费资格...");
				}
			}
		}
		
		public int getSize() {
			return list.size();
		}
	}
	
}

 

 

 

 

 

 

 

54454hhj
关注
专栏目录
Java并发Lock和Condition
李孟的博客
11-15 568
文章目录一.简介二.原理2.1 管程2.2 可见性2.3 可重入锁2.4 公平锁与非公平锁2.5 用锁的最佳实践2.6 示例 一.简介 Java SDK并发包通过Lock和Condition两个接口来实现管程，其中Lock用于解决互斥问题，Condition 用于解决同步问题。 二.原理 2.1 管程 在 Java 的 1.5 版本中，synchronized 性能不如 SDK 里面的 Lock，但 1.6 版本之后，synchronized 做了很多优化，将性能追了上来，所以 1.6 之后的版本又有人推荐
Lock和Condition简结
码上一元
01-11 304
并发编程两大核心问题 互斥：同一时刻只允许一个线程访问共享资源； 同步：线程间如何通信、协作； Java SDK并发包通过Lock和Condition两个接口实现管程，Lock解决互斥问题，Condition解决同步问题。 Java提供的synchronized也是管程的一种实现，既然Java语言层面已经实现了管程了，为什么还要在SDK里提供另外一种实现呢？ 死锁发生的4个条件 互斥，共享资源X和Y只能被一个线程占用； 占有且等待，线程T1已经取得共享资源X，在等待共享资源Y的时候，不释放.
ReentrantLock源码lock和tryLock区别
小小少年的博客
04-13 599
在reentrantLock中，提供了一个lock和一个tryLock方法，这两个方法是有区别的，这篇笔记主要记录下具体的区别信息 结论 其实对于这个两个方法，简单来说，tryLock()方法，返回的是一个boolean类型变量，返回true，表示加锁成功，返回false，表示加锁失败，但是这个方法是没有排队的功能的 lock()方法有两个功能：尝试加锁 + 排队；所以，lock方法如果加锁失败，会去排队，我们也可以简单的认为，lock = tryLock + 排队方法 lock()源码 lock在加锁的时
TryLock使用方式
石头视角
01-28 5398
尝试获取锁，如果获取到了执行同步的地方，如果获取不到那么返回的是false将做其他的事情。 public class TestTryLcok implements Runnable{ private static Lock locks = new ReentrantLock(); @Override public void run() { try {
tryLock的使用
Mirage__的博客
05-02 1470
tryLock的使用业务场景方法说明用法 业务场景 对于某些并发业务场景，我们可能想保证同一时刻只有一个线程在执行某一方法。 例如：对于缓存的初始化工作，此时我们可以使用tryLock()方法对代码进行上锁，只有拿到锁的线程可以执行操作，而其他线程则只会在进行一次尝试后返回false。 方法说明 Acquires the lock only if it is not held by another thread at the time of invocation. 只有在调用时它是空闲的才能获取锁。 获取锁
【代码】ReentrantLock使用tryLock进行尝试锁定
学亮编程手记
05-07 2326
使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行 可以根据tryLock的返回值来判定是否锁定 也可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unclock的处理，必须放到finally中 import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; ...
ReentrantLock里面lock和tryLock的区别
GracefulGuigui的博客
06-24 4220
ReentrantLock ReentrantLock（轻量级锁）也可以叫对象锁，可重入锁，互斥锁。synchronized重量级锁，JDK前期的版本lock比synchronized更快，在JDK1.5之后synchronized引入了偏向锁，轻量级锁和重量级锁。以致两种锁性能旗鼓相当，看个人喜欢，本文主要介绍一下lock和tryLock的区别。 public void lock() { sync.lock(); } public void lockInterruptibly() thro
生产者-消费者（lock和condition）.zip
08-07
在这个场景中，"生产者-消费者（lock和condition）.zip"的文件内容可能包含一个使用Java语言实现的示例，它利用了`java.util.concurrent.locks.Lock`接口和`Condition`接口来解决这个问题。 `Lock`接口是Java并发库...
lock和condition使用场景
最新发布
08-14
在并发编程中，我们使用lock和condition能够更好地控制多个线程的执行顺序和并发访问共享资源的情况，提高程序的性能和正确性。 ### 回答3： Lock（锁）和Condition（条件）都是多线程编程中常用的工具，用于实现...
Java并发编程 | Lock和Condition
JavaShark的博客
05-26 226
前言 我们回顾下前面文章所说的Java并发编程的万能钥匙：管程，管程是把共享变量和对共享变量的操作给封装起来实现互斥，然后管程内部的条件变量以及条件变量的等待队列实现了线程的同步。 同时Java语言的synchronized是管程的一种实现，只不过只有一个条件变量的管程模型；那Java并发包为什么还给出其他的管程实现呢 就比如本篇内容就是通过Lock和Condition这俩个接口来实现管程，其中Lock用于解决互斥问题，Condition用于解决同步问题。 所以理解为什么Java并发包要开发这俩个工
详解Java多线程tryLock()方法使用
fmz2222的博客
03-24 1622
tryLock()仅在调用时锁定未被其他线程持有的锁，如果调用方法时，锁对象对其他线程持有，则放弃，调用方法尝试获得没，如果该锁没有被其他线程占用则返回真实的表示锁定成功；tryLock(长时间，时间单位单位)的作用在给定等待时长内锁没有被另外的线程持有，并且当前线程也没有被中断，则获得该锁，通过该方法可以实现锁对象的限时等待。//假设线程-0线程先持有锁，完成任务需要四秒钟，线程一线程尝试获得锁，线程一线程在3秒内还没有获得锁的话，线程一线程会放弃。当前线程().getName()'没有获得锁');
ReentrantLock的lock(), tryLock(), tryLock(long timeout, TimeUnit unit), lockInterruptibly() 及使用场景示例
michaelgo的博客
08-07 2万+
一直在用concurrent包里的东西，最近想研究一下个中细节，先从ReentrantLock提供的集中获取锁的方式开始吧。 1.ReentrantLock简要介绍 简单介绍一下ReentrantLock，可重入锁，互斥锁，提供了fair和unfair两种模式的锁。默认构造函数是unfair的锁，如果初始化时传入true的参数则会返回fair锁。所谓不公平就是在锁可获取时，不用考虑该锁队列是否...
java.util.concurrent.locks.ReentrantLock.tryLock()
LINDONG666
08-24 640
只有在锁没有被其他线程持有的时候才获取锁 在锁没有被其他线程持有的时候获取锁并返回true值, 将锁计数器置为1. 即使已将此锁设置为使用公平排序策略，如果该锁可用，则调用tryLock()将立即获取该锁，而不管其他线程当前是否正在等待该锁. 这种”恶霸式（barging）”的行为在某些情况下会很有用，即使它打破了公平. 如果你想保持这个锁的公正性, 则使用tryLoc...
Lock锁-------tryLock()方法
热门推荐
qq_43323776的博客
10-04 5万+
这一次主要学习Lock接口中的**tryLock()**方法。 tryLock()方法是有返回值的，返回值是Boolean类型。它表示的是用来尝试获取锁：成功获取则返回true；获取失败则返回false，这个方法无论如何都会立即返回。不会像synchronized一样，一个线程获取锁之后，其他锁只能等待那个线程释放之后才能有获取锁的机会。 一般情况下的tryLock获取锁匙这样使用的： //实例化...
ReentrantLock -- tryLock
攀攀的专栏
09-01 577
package concurrent; import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TestTryLock { private List<Object> list = new ArrayList<Object>(
tryLock的一个使用示例
XMEHB的博客
08-06 413
就算是有几年工作经验的，如果没有专业的训练，也不一定能写出一手线程安全的代码，对于一般的web开发而言，多线程相关的部分都封装在web server里了，而平时的业务开发不涉及这些高级特...
ReentrantLock之tryLock()、lock()、lockInterruptibly()
qq_38384102的博客
11-13 322
 * tryLock不管是否获得锁，立即返回；获得锁，返回true，没有获得锁，返回false；  * lock不受interr影响，会一直waiting；  * lockInterruptibly受interr影响，无论是先lockInterruptibly后interrupt，还是先interrupt后lockInterruptibly，会TERMINATED，并且interrupt触发loc...
java中ReentrantLock类的tryLock的标准例子和用法
及时雨的csdn
08-21 1832
package Lock; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockDemo { .
ReentrantLock 以及 Condition深度解析
zhujiangtaotaise的专栏
09-02 2626
前言 之前写过关于AQS的文章，也讲了关于 ReetrantLock 的源码分析。写ReentrantLock那么还是得提下 AQS 的。 一、关于AQS 中几个重要的属性 AQS 中维护了一个很重要的变量 state, 它是int型的，表示加锁的状态，初始状态值为0； 另外 AQS 还维护了一个很重要的变量exclusiveOwnerThread，它表示的是获得锁的线程，也叫独占线程，ReentrantLock中的可重入就是用到该属性，当 state != 0 但是 exclusiveOwnerThre
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值