多线程实战（一）——多线程轮流调用

师傅留了一个作业让我们来熟悉多线程问题，原本对多线程一直处于理论阶段，大二学操作系统的时候写的也是一知半解，今天拿到这道题又好好的做了一遍。

题目：审核系统有一批工单需要处理，现在启动三个线程进行处理，要求线程1处理工单id mod 3 = 1的工单，线程2处理工单id mod 3 = 2的工单，线程3处理工单id mod 3 = 0的工单，直到工单全部处理完毕，假设工单有1000个，工单编号从1-1000，工单处理过程简化为打印工单id，要求工单必须按顺序处理，即打印结果必须保证从1-1000从小到大递增

1、请使用原始synchronized,wait(),notify(),notifyAll()等方式来实现。

2、使用JDK1.5并发包提供的Lock,Condition等类的相关方法来实现。

对于第一个问题，网上有很多相关的代码，有重写三个run方法的，甚至有创建1000个进程的，很多都不是特别的好。受到一篇博文的启发@zyplus，我写出了下面的代码，优势之处在于传参的话只需要重写一个run方法，代码也相对优美一些。具体思想是这样的，其实我们要做的知识对3个线程的循环调用，为了控制三个线程的前后顺序，需要定义两个锁，一个是prev，即前一个线程持有的对象锁，第二个是self，用来使下一个线程进行等待和唤醒状态转换。

public class GongdanHandler extends Thread {

private String name;
private Object prev;
private Object self;
private static int id = 1;

private GongdanHandler(String name, Object prev, Object self) {
this.name = name;
this.prev = prev;
this.self = self;
}

public void run() {
while (id <= 1000) {
synchronized (prev) {
synchronized (self) {
System.out.println(name + "处理工单" + id);
id++;

self.notify();
}
try {
prev.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}

public static void main(String[] args) throws Exception {

Object a = new Object();
Object b = new Object();
Object c = new Object();
GongdanHandler ta = new GongdanHandler("线程1", c, a);
GongdanHandler tb = new GongdanHandler("线程2", a, b);
GongdanHandler tc = new GongdanHandler("线程3", b, c);

ta.start();
tb.start();
tc.start();
}
}

对于第二个问题，就有点头疼了，看了不少对于Lock和Condition的介绍和代码，感觉还是有点懵逼，对于Condition，作为新手的我看了这些方法

await(): 使当前线程在接到信号或被中断之前处于等待状态。

signal(): 唤醒一个等待线程。

signalAll(): 唤醒所有的等待线程。

这样的话，Condition承担的工作其实就是代替了被锁锁住的对象，使它的使用更加灵活且更加好理解一些了。

本来我还是想把代码写成和上一个代码相同的思想的，这样会大大的简化代码，但是过程中发现，在线程中需要使用到Condition对象，觉得传的参数有点小多，就多重写几个run吧（在写这段话的时候我把这两份代码又进行了一次比较，觉得还是第一份代码写得好，尝试着把第二份代码也像上一个那样去写，虽然好像传的参数有点多，出了点小bug，公司没大有人了，先把这篇先写完吧）

package test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* Created by bjhl on 16/8/1.
*/
public class GongdanHandler2 extends Thread{

static class NumberWrapper {
public static int value = 1;
}

public static void main(String[] args) {

//初始化可重入锁
final Lock lock = new ReentrantLock();

final Condition reachOneCondition = lock.newCondition();
final Condition reachTwoCondition = lock.newCondition();
final Condition reachThreeCondition = lock.newCondition();

final NumberWrapper num = new NumberWrapper();

Thread t1 = new Thread(new Runnable() {
public void run() {
while (num.value <= 1000) {
try {
lock.lock();
System.out.println("t1等待");
if(num.value != 1)
reachOneCondition.await();
if(num.value > 1000) break;
if (num.value % 3 == 1) {
System.out.println("t1处理:" + num.value);
num.value++;
}
reachTwoCondition.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}

});
Thread t2 = new Thread(new Runnable() {
public void run() {
while (num.value <= 1000) {
try {
lock.lock();
System.out.println("t2等待");
reachTwoCondition.await();
if(num.value > 1000) break;
if (num.value % 3 == 2) {
System.out.println("t2处理:" + num.value);
num.value++;
}
reachThreeCondition.signal();
}catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
}

});
Thread t3 = new Thread(new Runnable() {
public void run() {
while (num.value <= 1000) {
try {
lock.lock();
System.out.println("t3等待");
reachThreeCondition.await();
if(num.value > 1000) break;
if (num.value % 3 == 0) {
System.out.println("t3处理:" + num.value);
num.value++;
}
reachOneCondition.signal();
}catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
}

});

t3.start();
t2.start();
t1.start();

}

}

确实不大好看呀，这个代码也是受到一个博文的启发，一开始我的运行结果是这样的

t1等待

t1处理:1

t1等待

t2等待

t3等待

死锁，为什么会发生这种情况，因为在t1中执行reachTwoCondition.signal();的时候t2中的reachTwoCondition还没进入等待状态，我学习的那篇博文的博主教导我们把线程的顺序倒过来start不就行了么，一开始我觉得挺有道理的，也像他那样做了，运行一下，也挺成功的，后来有运行了几次，发现成功到1000是个概率事件，经常会在500多呀800多呀甚至30多发生死锁。为什么，因为循环一定的次数之后总会有概率发生之前这样t1中执行reachTwoCondition.signal();的时候t2中的reachTwoCondition还没进入等待状态，t2t3同样状态的情况，这就很尴尬了，我目前的解决办法是

<span style="white-space:pre">	</span>reachTwoCondition.await();
Thread.sleep(10);//每个线程中加了这么一句
if(num.value > 1000) break;

即在等待被唤醒后先等上一小段时间，但这确实不是一个非常好的办法，我再继续想办法