admin管理员组文章数量:1599543
文章目录
- 什么是 Condition?
- Condition 的定义
- Condition 中的方法
- await()
- await(long time,TimeUnit unit)
- awaitNanos(long nanosTimeout)
- awaitUninterruptibly()
- awaitUntil(Date deadline)
- signal()
- signalAll()
- 举例:(Condition 的使用)
什么是 Condition?
Condition 是 java.util.concurrent.locks 包下的一个接口,该接口提供一个线程挂起执行的能力,直到给定的条件为真。Condition 对象必须绑定到 Lock,并使用 new Condition() 方法获取对象
Condition 的定义
Condition 接口的定义如下:
public interface Condition
Condition 中的方法
await()
使当前线程等待,直到发出信号或被中断为止
与此条件相关联的锁被原子释放,并且出于线程调度目的,当前线程被禁用,并且处于休眠状态,直到发生以下四种情况之一:
- 其他一些线程为此条件调用 signal() 方法,并且当前线程恰好被选择为要唤醒的线程
- 要么其他一些线程为此条件调用 signalAll() 方法
- 要么其他一些线程中断当前线程,并支持中断线程挂起
- 要么发生 “虚假唤醒”
在所有情况下,在此方法可以返回之前,当前线程必须重新获取与此条件关联的锁。 当线程返回时,可以保证保持此锁。
如果当前线程:
- 在进入此方法时已设置其中断状态
- 要么在等待期间中断并支持中断线程挂起,然后抛出InterruptedException并清除当前线程的中断状态。 在第一种情况下,没有规定在释放锁之前是否进行了中断测试
void await() throws InterruptedException
await(long time,TimeUnit unit)
使当前线程等待,直到发出信号或中断它,或者经过指定的等待时间。 此方法在行为上等效于:awaitNanos(unit.toNanos(time)) > 0
// time 表示等待的最长时间,unit 表示时间参数的时间单位
// 如果从方法返回之前等待时间已过,则返回false;否则返回true
boolean await(long time,TimeUnit unit) throws InterruptedException
awaitNanos(long nanosTimeout)
使当前线程等待,直到发出信号或中断它,或者经过指定的等待时间
long awaitNanos(long nanosTimeout) throws InterruptedException
awaitUninterruptibly()
使当前线程等待,直到发出信号
void awaitUninterruptibly()
awaitUntil(Date deadline)
使当前线程等待,直到发出信号或被中断或指定的截止时间过去为止
与此条件相关联的锁被原子释放,并且出于线程调度的目的,当前线程被禁用,并且处于休眠状态,直到发生以下五种情况之一:
- 其他一些线程为此条件调用 signal() 方法,并且当前线程恰好被选择为要唤醒的线程
- 其他一些线程为此条件调用 signalAll()方法
- 其他一些线程中断当前线程,并支持中断线程挂起
- 指定的期限已过
- 发生 “虚假唤醒”
boolean awaitUntil(Date deadline) throws InterruptedException
signal()
唤醒一个等待线程
如果有任何线程在这种情况下等待,则选择一个线程进行唤醒。 然后,该线程必须重新获取锁,然后才能从等待返回
void signal()
signalAll()
唤醒所有等待的线程
如果有任何线程在这种情况下等待,那么它们都将被唤醒。 每个线程必须重新获取锁,然后才能从等待状态返回
void signalAll()
举例:(Condition 的使用)
package com.java.springtest.testdemo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author Woo_home
* @create by 2020/2/2
*/
public class TestThread {
// 自定义一个队列
static class ItemQueue {
private Object[] items = null;
private int current = 0;
private int placeIndex = 0;
private int removeIndex = 0;
private Lock lock;
private Condition isEmpty;
private Condition isFull;
public ItemQueue(int capacity) {
this.items = new Object[capacity];
lock = new ReentrantLock();
isEmpty = lock.newCondition();
isFull = lock.newCondition();
}
public void add(Object item) throws InterruptedException {
lock.lock();
while (current >= items.length) {
isFull.await();
}
items[placeIndex] = item;
placeIndex = (placeIndex + 1) % items.length;
++current;
isEmpty.signal();
lock.unlock();
}
public Object remove() throws InterruptedException {
Object item = null;
lock.lock();
while (current <= 0) {
isEmpty.await();
}
item = items[removeIndex];
removeIndex = (removeIndex + 1) % items.length;
--current;
isFull.signal();
lock.unlock();
return item;
}
public boolean isEmpty() {
return (items.length == 0);
}
}
// 创建生产者并继承 Thread 类
static class Producer extends Thread {
private final ItemQueue itemQueue;
public Producer(ItemQueue itemQueue) {
this.itemQueue = itemQueue;
}
@Override
public void run() {
String[] numbers = {"1","2","3","4","5","6","7","8","9","10","11","12"};
try {
for (String number : numbers) {
itemQueue.add(number);
System.out.println("[Producer]:" + number);
}
itemQueue.add(null);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 创建消费者并继承 Thread 类
static class Consumer extends Thread {
private final ItemQueue itemQueue;
public Consumer(ItemQueue itemQueue) {
this.itemQueue = itemQueue;
}
@Override
public void run() {
try {
do {
Object number = itemQueue.remove();
System.out.println("[Consumer]:" + number);
if (number == null) {
return;
}
} while (!itemQueue.isEmpty());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
ItemQueue itemQueue = new ItemQueue(10);
// 创建生产者与消费者
Thread producer = new Producer(itemQueue);
Thread consumer = new Consumer(itemQueue);
// 启动线程
producer.start();
consumer.start();
// 等待两个线程终止
producer.join();
consumer.join();
}
}
执行程序输出如下:
[Producer]:1
[Producer]:2
[Producer]:3
[Producer]:4
[Producer]:5
[Producer]:6
[Producer]:7
[Producer]:8
[Consumer]:1
[Consumer]:2
[Consumer]:3
[Consumer]:4
[Consumer]:5
[Consumer]:6
[Consumer]:7
[Consumer]:8
[Consumer]:9
[Producer]:9
[Producer]:10
[Producer]:11
[Producer]:12
[Consumer]:10
[Consumer]:11
[Consumer]:12
[Consumer]:null
版权声明:本文标题:Condition 的简单使用 内容由热心网友自发贡献,该文观点仅代表作者本人, 转载请联系作者并注明出处:https://m.elefans.com/dongtai/1728322127a1153962.html, 本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,一经查实,本站将立刻删除。
发表评论