线程协作-生产者/消费者
上一篇讲述了线程的互斥(同步)，但是在很多情况下，仅仅同步是不够的，还需要线程与线程协作(通信)，生产者/消费者问题是一个经典的线程同步以及通信的案例。该问题描述了两个共享固定大小缓冲区的线程，即所谓的“生产者”和“消费者”在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者，通常采用线程间通信的方法解决该问题。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。本文讲述了JDK5之前传统线程的通信方式，更高级的通信方式可参见后续文章。
假设有这样一种情况，有一个盘子，盘子里只能放一个鸡蛋，A线程专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B线程专门从盘子里取鸡蛋，如果盘子里没鸡蛋，则一直等到盘子里有鸡蛋。这里盘子是一个互斥区，每次放鸡蛋是互斥的，每次取鸡蛋也是互斥的，A线程放鸡蛋，如果这时B线程要取鸡蛋，由于A没有释放锁，B线程处于等待状态，进入阻塞队列，放鸡蛋之后，要通知B线程取鸡蛋，B线程进入就绪队列，反过来，B线程取鸡蛋，如果A线程要放鸡蛋，由于B线程没有释放锁，A线程处于等待状态，进入阻塞队列，取鸡蛋之后，要通知A线程放鸡蛋，A线程进入就绪队列。我们希望当盘子里有鸡蛋时，A线程阻塞，B线程就绪，盘子里没鸡蛋时，A线程就绪，B线程阻塞，代码如下：
import java.util.ArrayList;
import java.util.List;
/** 定义一个盘子类，可以放鸡蛋和取鸡蛋 */
public class Plate {
/** 装鸡蛋的盘子 */
List<Object> eggs = new ArrayList<Object>();
/** 取鸡蛋 */
public synchronized Object getEgg() {
while (eggs.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Object egg = eggs.get(0);
eggs.clear();// 清空盘子
notify();// 唤醒阻塞队列的某线程到就绪队列
System.out.println("拿到鸡蛋");
return egg;
}
/** 放鸡蛋 */
public synchronized void putEgg(Object egg) {
while (eggs.size() > 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
eggs.add(egg);// 往盘子里放鸡蛋
notify();// 唤醒阻塞队列的某线程到就绪队列
System.out.println("放入鸡蛋");
}
static class AddThread implements Runnable {
private Plate plate;
private Object egg = new Object();
public AddThread(Plate plate) {
this.plate = plate;
}
public void run() {
plate.putEgg(egg);
}
}
static class GetThread implements Runnable {
private Plate plate;
public GetThread(Plate plate) {
this.plate = plate;
}
public void run() {
plate.getEgg();
}
}
public static void main(String args[]) {
Plate plate = new Plate();
for(int i = 0; i < 10; i++) {
new Thread(new AddThread(plate)).start();
new Thread(new GetThread(plate)).start();
}
}
} 输出结果：
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋 程序开始，A线程判断盘子是否为空，放入一个鸡蛋，并且唤醒在阻塞队列的一个线程，阻塞队列为空；假设CPU又调度了一个A线程，盘子非空，执行等待，这个A线程进入阻塞队列；然后一个B线程执行，盘子非空，取走鸡蛋，并唤醒阻塞队列的A线程，A线程进入就绪队列，此时就绪队列就一个A线程，马上执行，放入鸡蛋；如果再来A线程重复第一步，在来B线程重复第二步，整个过程就是生产者(A线程)生产鸡蛋，消费者(B线程)消费鸡蛋。
前段时间看了张孝祥老师线程的视频，讲述了一个其学员的面试题，也是线程通信的，在此也分享一下。
题目：子线程循环10次，主线程循环100次，如此循环100次，好像是空中网的笔试题。
public class ThreadTest2 {
public static void main(String[] args) {
final Business business = new Business();
new Thread(new Runnable() {
@Override
public void run() {
threadExecute(business, "sub");
}
}).start();
threadExecute(business, "main");
}
public static void threadExecute(Business business, String threadType) {
for(int i = 0; i < 100; i++) {
try {
if("main".equals(threadType)) {
business.main(i);
} else {
business.sub(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Business {
private boolean bool = true;
public synchronized void main(int loop) throws InterruptedException {
while(bool) {
this.wait();
}
for(int i = 0; i < 100; i++) {
System.out.println("main thread seq of " + i + ", loop of " + loop);
}
bool = true;
this.notify();
}
public synchronized void sub(int loop) throws InterruptedException {
while(!bool) {
this.wait();
}
for(int i = 0; i < 10; i++) {
System.out.println("sub thread seq of " + i + ", loop of " + loop);
}
bool = false;
this.notify();
}
} 大家注意到没有，在调用wait方法时，都是用while判断条件的，而不是if，在wait方法说明中，也推荐使用while，因为在某些特定的情况下，线程有可能被假唤醒，使用while会循环检测更稳妥。wait和notify方法必须工作于synchronized内部，且这两个方法只能由锁对象来调用。
线程中断、让步、睡眠、合并
理解了线程同步和线程通信之后，再来看本文的知识点就会简单的多了，本文是做为传统线程知识点的一个补充。有人会问：JDK5之后有了更完善的处理多线程问题的类(并发包)，我们还需要去了解传统线程吗？答：需要。在实际开发中，无外乎两种情况，一个是开发新内容，另一个是维护原有程序。开发新内容可以使用新的技术手段，但是我们不能保证原有程序是用什么实现的，所以我们需要了解原有的。另外一点，了解传统线程的工作原理，使我们在使用并发包时更加得心应手。
线程中断：
线程中断涉及到三个方法，如下：
| 返回值 | 方法名 | 备注 |
|---|---|---|
| void | interrupt() | 中断线程。 |
| static boolean | interrupted() | 测试当前线程是否已经中断。 |
| boolean | isInterrupted() | 测试线程是否已经中断。 |
interrupt()方法用于中断线程，通常的理解来看，只要某个线程启动后，调用了该方法，则该线程不能继续执行了，来看个小例子：
public class InterruptTest {
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread("MyThread");
t.start();
Thread.sleep(100);// 睡眠100毫秒
t.interrupt();// 中断t线程
}
}
class MyThread extends Thread {
int i = 0;
public MyThread(String name) {
super(name);
}
public void run() {
while(true) {// 死循环，等待被中断
System.out.println(getName() + getId() + "执行了" + ++i + "次");
}
}
} 运行后，我们发现，线程t一直在执行，没有被中断，原来interrupt()是骗人的，汗！其实interrupt()方法并不是中断线程的执行，而是为调用该方法的线程对象打上一个标记，设置其中断状态为true，通过isInterrupted()方法可以得到这个线程状态，我们将上面的程序做一个小改动：
public class InterruptTest {
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread("MyThread");
t.start();
Thread.sleep(100);// 睡眠100毫秒
t.interrupt();// 中断t线程
}
}
class MyThread extends Thread {
int i = 0;
public MyThread(String name) {
super(name);
}
public void run() {
while(!isInterrupted()) {// 当前线程没有被中断，则执行
System.out.println(getName() + getId() + "执行了" + ++i + "次");
}
}
} 这样的话，线程被顺利的中断执行了。很多人实现一个线程类时，都会再加一个flag标记，以便控制线程停止执行，其实完全没必要，通过线程自身的中断状态，就可以完美实现该功能。如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。 我们可以捕获该异常，并且做一些处理。另外，Thread.interrupted()方法是一个静态方法，它是判断当前线程的中断状态，需要注意的是，线程的中断状态会由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。
线程让步
线程让步，其方法如下：
| 返回值 | 方法名 | 备注 |
|---|---|---|
| static void | yield() | 暂停当前正在执行的线程对象，并执行其他线程 |
线程让步用于正在执行的线程，在某些情况下让出CPU资源，让给其它线程执行，来看一个小例子：
public class YieldTest {
public static void main(String[] args) throws InterruptedException {
// 创建线程对象
YieldThread t1 = new YieldThread("t1");
YieldThread t2 = new YieldThread("t2");
// 启动线程
t1.start();
t2.start();
// 主线程休眠100毫秒
Thread.sleep(100);
// 终止线程
t1.interrupt();
t2.interrupt();
}
}
class YieldThread extends Thread {
int i = 0;
public YieldThread(String name) {
super(name);
}
public void run() {
while(!isInterrupted()) {
System.out.println(getName() + "执行了" + ++i + "次");
if(i % 10 == 0) {// 当i能对10整除时，则让步
Thread.yield();
}
}
}
} 输出结果略，从输出结果可以看到，当某个线程(t1或者t2)执行到10次、20次、30次等时，就会马上切换到另一个线程执行，接下来再交替执行，如此往复。注意，如果存在synchronized线程同步的话，线程让步不会释放锁(监视器对象)。
线程睡眠
线程睡眠涉及到两个方法，如下：
| 返回值 | 方法名 | 备注 |
|---|---|---|
| static void | sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。 |
| static void | sleep(long millis, int nanos) | 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。 |
线程睡眠的过程中，如果是在synchronized线程同步内，是持有锁(监视器对象)的，也就是说，线程是关门睡觉的，别的线程进不来，来看一个小例子：
public class SleepTest {
public static void main(String[] args) {
// 创建共享对象
Service service = new Service();
// 创建线程
SleepThread t1 = new SleepThread("t1", service);
SleepThread t2 = new SleepThread("t2", service);
// 启动线程
t1.start();
t2.start();
}
}
class SleepThread extends Thread {
private Service service;
public SleepThread(String name, Service service) {
super(name);
this.service = service;
}
public void run() {
service.calc();
}
}
class Service {
public synchronized void calc() {
System.out.println(Thread.currentThread().getName() + "准备计算");
System.out.println(Thread.currentThread().getName() + "感觉累了，开始睡觉");
try {
Thread.sleep(10000);// 睡10秒
} catch (InterruptedException e) {
return;
}
System.out.println(Thread.currentThread().getName() + "睡醒了，开始计算");
System.out.println(Thread.currentThread().getName() + "计算完成");
}
} 输出结果：
t1准备计算
t1感觉累了，开始睡觉
t1睡醒了，开始计算
t1计算完成
t2准备计算
t2感觉累了，开始睡觉
t2睡醒了，开始计算
t2计算完成 线程合并
线程合并涉及到三个方法，如下：
| 返回值 | 方法名 | 备注 |
|---|---|---|
| void | join() | 等待该线程终止。 |
| void | join(long millis) | 等待该线程终止的时间最长为 millis 毫秒。 |
| void | join(long millis, int nanos) | 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 |
线程合并是优先执行调用该方法的线程，再执行当前线程，来看一个小例子：
public class JoinTest {
public static void main(String[] args) throws InterruptedException {
JoinThread t1 = new JoinThread("t1");
JoinThread t2 = new JoinThread("t2");
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("主线程开始执行！");
}
}
class JoinThread extends Thread {
public JoinThread(String name) {
super(name);
}
public void run() {
for(int i = 1; i <= 10; i++)
System.out.println(getName() + getId() + "执行了" + i + "次");
}
} t1和t2都执行完才继续主线程的执行，所谓合并，就是等待其它线程执行完，再执行当前线程，执行起来的效果就好像把其它线程合并到当前线程执行一样。
线程优先级
线程最低优先级为1，最高优先级为10，看起来就有10个级别，但这10个级别能不能和CPU对应上，还未可知，Thread类中提供了优先级的三个常量，如下：
//所属类： java.lang.Thread
| 修饰域的关键字 | 常量名 | 表示值 |
|---|---|---|
| public static final int | MAX_PRIORITY | 10 |
| public static final int | MIN_PRIORITY | 1 |
| public static final int | NORM_PRIORITY | 5 |
我们创建线程对象后，如果不显示的设置优先级的话，默认为5。优先级可以看成一种特权，优先级高的，获取CPU调度的机会就大，优先级低的，获取CPU调度的机会就小，这个和我们现实生活很一样啊，优胜劣汰。线程优先级的示例就不写了，比较简单。
wait()和sleep()区别
区别太大了，但是在Java线程面试题中是很常见的问题，相信你阅读过本专栏后，能够轻松的解答，这里不再赘述。
本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/17560467，转载请注明。
602
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
