Java并发编程原理与实战二十二：Condition的使用
Condition的使用
Condition用于实现条件锁，可以唤醒指定的阻塞线程。下面来实现一个多线程顺序打印a,b,c的例子。
先来看用wait和notify的实现：
public class Demo {
private volatile int singal;
public synchronized void a() {
while (singal != 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("a");
singal++;
notifyAll();
}
public synchronized void b() {
while (singal != 1) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("b");
singal++;
notifyAll();
}
public synchronized void c() {
while (singal != 2) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("c");
singal = 0;
notifyAll();
}
public static void main(String[] args) {
Demo demo = new Demo();
A a = new A(demo);
B b = new B(demo);
C c = new C(demo);
new Thread(a).start();
new Thread(b).start();
new Thread(c).start();
}
}
class A implements Runnable {
private Demo demo;
public A(Demo demo) {
this.demo = demo;
}
@Override
public void run() {
while (true) {
demo.a();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class B implements Runnable {
private Demo demo;
public B(Demo demo) {
this.demo = demo;
}
@Override
public void run() {
while (true) {
demo.b();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class C implements Runnable {
private Demo demo;
public C(Demo demo) {
this.demo = demo;
}
@Override
public void run() {
while (true) {
demo.c();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
再来看一下用Condition的实现，可以发现Condition实现更方便，可以实现指定条件的唤醒：
public class DemoCondition {
private volatile int singal;
private Lock lock = new ReentrantLock();
private Condition a = lock.newCondition();
private Condition b = lock.newCondition();
private Condition c = lock.newCondition();
public void a() {
lock.lock();
while (singal != 0) {
try {
a.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("a");
singal++;
b.signal();
lock.unlock();
}
public void b() {
lock.lock();
while (singal != 1) {
try {
b.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("b");
c.signal();
singal++;
lock.unlock();
}
public void c() {
lock.lock();
while (singal != 2) {
try {
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("c");
a.signal();
singal = 0;
lock.unlock();
}
public static void main(String[] args) {
DemoCondition demo = new DemoCondition();
A a = new A(demo);
B b = new B(demo);
C c = new C(demo);
new Thread(a).start();
new Thread(b).start();
new Thread(c).start();
}
}
class A implements Runnable {
private DemoCondition demo;
public A(DemoCondition demo) {
this.demo = demo;
}
@Override
public void run() {
while (true) {
demo.a();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class B implements Runnable {
private DemoCondition demo;
public B(DemoCondition demo) {
this.demo = demo;
}
@Override
public void run() {
while (true) {
demo.b();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class C implements Runnable {
private DemoCondition demo;
public C(DemoCondition demo) {
this.demo = demo;
}
@Override
public void run() {
while (true) {
demo.c();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2.用Condition实现一个有界队列。
public class MyQueue<E> {
private Object[] obj;
// 添加操作下标
private int addIndex;
// 删除操作下标
private int removeIndex;
// 实际队列长度
private int queueSize;
private Lock lock = new ReentrantLock();
private Condition add = lock.newCondition();
private Condition remove = lock.newCondition();
public MyQueue(int count) {
this.obj = new Object[count];
}
public void add(E e) {
lock.lock();
// 队列已满则等待
while (queueSize == obj.length) {
try {
System.out.println(Thread.currentThread().getName() + " 队列已满，不能入队");
add.await();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
obj[addIndex++] = e;
if (addIndex == obj.length - 1) {
addIndex = 0;
}
queueSize++;
System.out.println(Thread.currentThread().getName() + " 当前队列大小: " + queueSize);
remove.signal();
lock.unlock();
}
public void remove() {
lock.lock();
// 队列已空则等待
while (queueSize == 0) {
try {
System.out.println(Thread.currentThread().getName() + " 队列已空，无法出队");
remove.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
obj[removeIndex] = null;
if (++removeIndex == obj.length) {
removeIndex = 0;
}
queueSize--;
System.out.println(Thread.currentThread().getName() + " 当前队列长度: " + queueSize);
add.signal();
lock.unlock();
}
public static void main(String[] args) {
final MyQueue<Integer> myQueue = new MyQueue<>(4);
new Thread() {
@Override
public void run() {
while (true) {
myQueue.add(1);
}
}
}.start();
new Thread() {
@Override
public void run() {
myQueue.remove();
}
}.start();
}
}
参考资料：
《java并发编程实战》 龙果学院
