当线程在系统内运行时,线程的调度具有一定的透明性,程序通常无法准确控制线程的轮换执行,但Java也提供了一些机制来保证线程协调运行。
一.传统的线程通信
假设现在系统中有两个线程,这两个线程分别代表存款者和取钱者,现在假设系统有一个特殊的要求,系统要求存款者和取钱者不断地重复存款、取钱的动作,并且要求每当存款者将钱存入指定账户后,取钱者就立即取出该笔钱。不允许存款者连续两次存钱,也不允许取钱者联系两次取钱。
为了实现这个功能,可以借助于Object类提供的wait()、notify()和notifyAll() 三个方法,这三个方法并不属于Thread类,而是属于Object类。但这三个方法必须由同步监视器来调用,这可分成以下两种情况。
(1)对于使用synchronized修饰的同步方法,因为该类的默认实例(this)就是同步监视器,所以可以在同步方法中直接调用这三个方法。
(2)对于使用synchronized修饰的同步代码块,同步监视器是synchronized后括号里的对象,所以必须使用该对象调用这三个方法。
关于这三个方法的解释如下:
(1)wait() : 导致当前线程等待,直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。该wait()方法有三种形式——无时间参数的wait(一直等待,直到其他线程通知)、带毫秒参数的wait()和带毫秒、毫微秒的wait() (这两种方法都是等待指定时间后自动苏醒)。调用wait()方法的当前线程会释放对该同步监视器的锁定。
(2)notify() : 唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待,则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该同步监视器的锁定后(使用wait()方法),才可以执行被唤醒的线程。
(3)notifyAll() : 唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后,才可以执行被唤醒的线程。
程序中可以通过一个flag来标识账户中是否已有存款,当flag为false时,表明账户中没有存款,存款者线程可以向下执行,当存款者把钱存入账户后,将flag设为true,并调用notify()或notifyAll()方法来唤醒其他线程;当存款者线程进入线程体后,如果flag为true就调用wait()方法让线程等待。
当flag为true时,表明账户中已经存入了存款,则取钱者线程可以向下执行,当取钱者把钱从账户中取出时,将flag设为false,并调用notify()或notifyAll()方法来唤醒其他线程;当取钱者线程进入线程体后,如果flag为false就调用wait()方法让线程等待。
本程序为Account类提供draw()和deposit()两个方法,分别对应该账户的取钱、存款等操作,因为这两个方法可能需要并发修改Account类的balance成员变量的值,所以这两个方法都使用synchronized修饰成同步方法。除此之外,这两个方法还使用了wait()、notifiyAll()来控制线程的协作。
Account类
代码片1
public class Account {
private String accountNo;
private double balance;
//标识账户中是否已有存款的flag
private boolean flag = false;
public Account() {
}
public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public synchronized void draw(double drawAmount) {
try {
if (!flag) {
//如果flag为假,表明账户中还没有人存钱进去,取钱方法阻塞
wait();
} else {
//执行取钱操作
System.out.println(Thread.currentThread().getName() + "取钱:" + drawAmount);
balance -= drawAmount;
System.out.println("账户余额为:" + balance);
flag = false;
//唤醒其他线程
notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void deposit(double depositAmount) {
try {
if (flag) {
//如果flag为真,表明账户中已有人存钱进去,存钱方法阻塞
wait();
} else {
//执行存款操作
System.out.println(Thread.currentThread().getName() + "存钱:" + depositAmount);
balance += depositAmount;
System.out.println("账户余额为:" + balance);
flag = true;
notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
代码片2
public class DrawThread extends Thread {
private Account account;
private double drawAmount;
public DrawThread(String name, Account account, double drawAmount) {
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
account.draw(drawAmount);
}
}
}
代码片3
public class DepositThread extends Thread {
private Account account;
private double drawAmount;
public DepositThread(String name, Account account, double drawAmount) {
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
account.deposit(drawAmount);
}
}
}
代码片4
Account account = new Account("1234567", 0);
new DrawThread("取钱者", account, 800).start();
new DepositThread("存钱者甲", account, 800).start();
new DepositThread("存钱者乙", account, 800).start();
new DepositThread("存钱者丙", account, 800).start();
运行该程序,可以看到存款者线程、取钱者线程交替执行的情形,每当存款者向账户中存入800元之后,取钱者线程立刻从账户中取出这笔钱.存款完成后账户余额总是800元,取钱结束后账户余额总是0元.运行该程序,会看到如下图的日志:
从上图可以看出,3个存款者线程随机地向账户中存款,只有1个取钱者线程执行操作.只有当取钱者取钱后,存款者才可以存款;同理,只有等存款者存款后,取钱者线程才可以取钱。
上图显示程序最后被阻塞无法继续向下执行,这是因为3个存款者线程共有300次存款操作,但1个取钱者线程只有100次取钱操作,所以程序最后被阻塞。
另外,需要说明的是,阻塞并不是死锁.对于上述情况,取钱者线程已经执行结束,而存款者线程只是在等待其他线程来取钱而已,并不是等待其他线程释放同步监视器。
二.使用Condition控制线程通信
如果程序不使用synchronized关键词来保证同步,而是直接使用Lock对象来保证同步,则系统中不存在隐式的同步监视器,也就不能使用wait()、notify()、notifyAll()方法进行线程通信了。
当使用Lock对象来保证同步时,Java提供了一个Condition类来保持协调,使用Condition可以让那些得到Lock对象却无法继续执行的线程释放Lock对象,Condition对象也可以唤醒其他处于等待的线程。
Condition将同步监视器方法(wait()、notify()、notifyAll())分解成截然不同的对象,以便通过将这些对象与Lock对象组合使用,为每个对象提供多个等待集(wait-set)。在这种情况下,Lock替代了同步方法与同步代码块,Condition替代了同步监视器的功能。
Condition实例被绑定在了一个Lock对象上.要获取特定Lock实例的Condition实例,调用Lock对象的newCondition()方法即可。Condition类提供了如下三个方法:
(1)awit() :类似于同步监视器上的wait()方法,导致当前线程等待,直到其他线程调用该Condition的signal()方法或signalAll()方法来唤醒该线程。该await() 方法有更多变体,如long awaitNanos(long nanosTimeout)、void awaitUnintterruptibly()、awaitUntil(Date deadline)等,可以完成更丰富的等待操作。
(2)signal() :唤醒在此Lock对象上等待的单个线程。如果所有线程都在此Lock对象上等待,则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该Lock对象的锁定后(使用await()方法),才可以执行被唤醒的线程。
(3)signalAll() :唤醒在此Lock对象上等待的所有线程。只有当前线程放弃对该Lock对象的锁定后,才可以执行被唤醒的线程。
下面代码中Account2使用Lock对象来控制同步,并使用Condition对象来控制线程的协调运行。
代码片5
package com.glh.threaddemo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Account2 {
//显示定义Lock对象
private final Lock lock = new ReentrantLock();
//获取指定Lock对象的Condition
private final Condition cond = lock.newCondition();
private String accountNo;
private double balance;
private boolean flag = false;
public Account2() {
}
public Account2(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void draw(double drawAmount) {
//加锁
lock.lock();
try {
if (!flag) {
//如果flag为假,表明账户中还没有存钱进入,取钱方法阻塞
cond.await();
} else {
System.out.println(Thread.currentThread().getName() + "取钱:" + drawAmount);
balance -= drawAmount;
System.out.println("账户余额为:" + balance);
flag = false;
//唤醒其他线程
cond.signalAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//使用finally释放锁
lock.unlock();
}
}
public void deposit(double depositAmount) {
lock.lock();
try {
if (flag) {
//如果flag为真,表明账户中已有人存钱进入,存钱方法阻塞
cond.await();
} else {
//执行存款操作
System.out.println(Thread.currentThread().getName() + "存钱:" + depositAmount);
balance += depositAmount;
System.out.println("账户余额为:" + balance);
flag = true;
//唤醒其他线程
cond.signalAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
而DrawThread类、DepositThread类与代码片2、3一样。
对比代码片1和代码片5,不难发现这两个程序的逻辑基本相似,只有现在显示地使用Lock对象来充当同步监视器,则需要使用Condition对象来暂停、唤醒指定线程。
最后运行的结果,也完全一样。
三.使用阻塞队列(BlockingQueue)控制线程通信
Java5提供了一个BlockingQueue接口,虽然BlockingQueue也是Queue的子接口,但它的主要用途并不是作为容器,而是作为线程同步的工具。BlockingQueue具有一个特征:当生产者线程视图向BlockingQueue中放入元素时,如果该队列已满,则该线程会被阻塞;当消费者线程视图从BlockingQueue中取出元素时,如果该队列已空,则该线程被阻塞。
程序的两个线程通过交替向BlockingQueue中放入元素、取出元素,即可很好地控制线程的通信。
BlockingQueue在实际开发中很少,具体的使用这里不详细展开。
412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
