Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set(wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。Lock可以实现互斥,但是不能实现同步,Condition可以实现通信,相当于notify或者notifyAll。Condition 实例实质上被绑定到一个锁上。
package Thread03;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionCommunication {
public static void main(String[] args) {
final Business business = new Business();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
business.sub(i);
}
}
}).start();
for (int i = 1; i <= 50; i++) {
business.main(i);
}
}
static class Business {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
private boolean bShouldSub = true;
public void sub(int i) {
lock.lock();
try {
while (!bShouldSub) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++) {
System.out.println("sub thread sequence of " + j
+ ", loop of " + i);
}
bShouldSub = false;
condition.signal();
} finally {
lock.unlock();
}
}
public void main(int i) {
lock.lock();
try {
while (bShouldSub) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++) {
System.out.println("main thread sequence of " + j
+ ", loop of " + i);
}
bShouldSub = true;
condition.signal();
} finally {
lock.unlock();
}
}
}
}
三个线程打印线程1打印两次,线程2打印4次,线程3打印6次,就这样打印50次,
package Thread03;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreeConditionCommunication {
public static void main(String[] args) {
final Business business = new Business();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
business.sub1(i);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
business.sub2(i);
}
}
}).start();
for (int i = 1; i <= 50; i++) {
business.sub3(i);
}
}
static class Business {
Lock lock = new ReentrantLock();
//需要创建3个condition
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
private int shouldSub = 1;
public void sub1(int i) {
lock.lock();
try {
while (shouldSub!=1) {//线程1等待
try {
condition1.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 2; j++) {//线程1执行
System.out.println("sub1 thread sequence of " + j
+ ", loop of " + i);
}
shouldSub=2;//执行完,把标志置为2
condition2.signal();//唤醒线程2
} finally {
lock.unlock();//释放锁
}
}
public void sub2(int i) {
lock.lock();
try {
while (shouldSub!=2) {
try {
condition2.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 4; j++) {
System.out.println("sub2 thread sequence of " + j
+ ", loop of " + i);
}
shouldSub =3 ;
condition3.signal();//唤醒线程3
} finally {
lock.unlock();
}
}
public void sub3(int i) {
lock.lock();
try {
while (shouldSub!=3) {
try {
condition3.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 6; j++) {
System.out.println("sub3 thread sequence of " + j
+ ", loop of " + i);
}
shouldSub = 1;
condition1.signal();
} finally {
lock.unlock();
}
}
}
}
假定有一个绑定的缓冲区,如果试图在空的缓冲区上执行 take 操作,则在某一个项变得可用之前,线程将一直阻塞;如果试图在满的缓冲区上执行 put 操作,则在有空间变得可用之前,线程将一直阻塞。编程实现。
package Thread03;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();//写线程
final Condition notEmpty = lock.newCondition();//读线程
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)//缓冲区满
notFull.await();//写线程等待
items[putptr] = x;
if (++putptr == items.length)//当指针为100,需要把指针置0
putptr = 0;
++count;//缓冲区中,数据数目加1
notEmpty.signal();//缓冲区不为空,唤醒读线程
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)//缓冲区为空
notEmpty.await();//读线程等待
Object x = items[takeptr];
if (++takeptr == items.length)//假如指针为100,则在从0开始
takeptr = 0;
--count;//取走一个,数据数目减1
notFull.signal();//缓冲区不满,唤醒写线程
return x;
} finally {
lock.unlock();
}
}
}