Java线程类1
Java线程类一
一、java.util.concurrent.CountDownLatch
通常线程是并发运行，并且不容易预测到哪个线程先执行，哪些后执行，所以通常在执行顺序上是相当公平的。但是，因为创建对象或者执行某些操作总是需要一定的时间，所以还是很难保证真正的公平。这时就需要某种机制来控制线程的运行时机。就比如说赛跑，必须等待所有的选手都已经站在起跑线上才能开始，而java.util.concurrent.CountDownLatch就是这样一个控制器，用于保证所有选手都在起跑线上。
例如以下程序：
for(int i = 0;i< 10;i++){
new Thread("Thread "+i){
public void run() {
System.out.println(getName()+" started");
}
}.start();
Thread.sleep(50);
}
如果没有某种保证机制，那基本上可以预测结果如下：
Thread 0 started Thread 1 started Thread 2 started Thread 3 started Thread 4 started Thread 5 started Thread 6 started Thread 7 started Thread 8 started Thread 9 started
因为后面的线程还没开始创建，前面的线程已经启跑了。
为了让他们在同一时间开跑，而不管创建的时机，可以如下：
//创建CountDownLatch，并指定countDown必须被调用10次
final CountDownLatch countDownLatch = new CountDownLatch(10);
for(int i = 0;i< 10;i++){
new Thread("Thread "+i){
public void run() {
try {
//在继续运行之前等待条件满足，也即所有的线程都准备好
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName()+" started");
}
}.start();
Thread.sleep(50);
//每创建完一个线程，调用一次countDown()方法，当高用到10次时，即条件满足
countDownLatch.countDown();
}
下面是某次运行的结果：
Thread 0 started Thread 8 started Thread 7 started Thread 6 started Thread 5 started Thread 1 started Thread 3 started Thread 2 started Thread 4 started Thread 9 started
同上面的结果比较，可以看出，结果基本已经是不可测的了。并且，所以的线程会在等待了差不多半秒之后同步运行。
简单的说 java.util.concurrent.CountDownLatch 就是一个倒数器，倒数到 0 后就开始执行所有等待的操作。
二、java.util.concurrent.CyclicBarrier
上面的 java.util.concurrent.CountDownLatch 可以用于控制线程同时执行，而 java.util.concurrent.CyclicBarrier 则可以用来控制线程收尾工作。例如，还是上面那个线程，如果我们想在所有的线程执行完后，再打印一下 Done ，则可以如下实现：
final CyclicBarrier cyclicBarrier = new CyclicBarrier(10, new Runnable() {
@Override
public void run() {
System.out.println("Done");
}
});
for(int i = 0; i<10;i++){
new Thread("Thread "+i){
public void run() {
System.out.println(getName());
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}.start();
}
运行结果如下：
Thread 0 Thread 1 Thread 5 Thread 3 Thread 6 Thread 4 Thread 7 Thread 8 Thread 2 Thread 9 Done
根据提示可以看到，它可以用于做收尾工作，比如说我们有一个查找程序，其中使用了多线程去分别查找，然后可以最后使用 CyclicBarrier 来将结果合并（当然也有其他的方法，这里只是说它可以做这件事）。
三、java.util.concurrent.Semaphore
信号量用于控制同时访问某一资源的线程数，例如系统上的某个文件，只想被最多5个线程同时使用，就可以用信号量在控制了。每次同过 acquire() 方法，获取访问权限，同时信号量减1，当信号量减为0时则不能有新的线程再获得权限；用release()方法释放权限，信号量加1，则可以有新的线程获得权限，例如：
final Semaphore semaphore = new Semaphore(2, true);
for(int i = 0;i<5;i++){
new Thread("Thread "+i){
public void run() {
try {
String threadName = getName();
System.out.println(threadName+"\t is waiting");
semaphore.acquire();
System.out.println(threadName+"\t is running");
sleep(30000);
System.out.println(threadName+"\t is finished");
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
semaphore.release();
}
}
}.start();
}
某次运行的结果：
Thread 0 is waiting Thread 1 is waiting Thread 1 is running Thread 3 is waiting Thread 4 is waiting Thread 0 is running Thread 2 is waiting
可以看到，5个线程都启动了，但是只有2个线程进入了running状态，其他3个处于waiting状态，30秒之后，先前2个running状态的线程finish了之后，剩下其中2个等待的线程才有机会开始进入运行状态：
Thread 1 is finished Thread 0 is finished Thread 3 is running Thread 4 is running
四、java.util.concurrent.Phaser
Java 7中新增了Phaser类，它有点类似于上面介绍的CyclicBarrier和CountDownLatch，但是它支持多阶段的运行/等待，并且支持增加移除观察者。比如说某个操作需要3步完成，其中每一步都需要多个线程配合：
final Phaser phaser = new Phaser(5);
for(int i = 0;i<5;i++){
new Thread("Thread "+i){
public void run() {
System.out.println(getName()+" are ready");
phaser.arriveAndAwaitAdvance();
System.out.println(getName()+" finished phase1");
phaser.arriveAndAwaitAdvance();
System.out.println(getName()+" finished phase2");
}
}.start();
}
某次运行的结果可能如下：
Thread 0 are ready Thread 2 are ready Thread 1 are ready Thread 3 are ready Thread 4 are ready Thread 4 finished phase1 Thread 1 finished phase1 Thread 3 finished phase1 Thread 0 finished phase1 Thread 2 finished phase1 Thread 2 finished phase2 Thread 1 finished phase2 Thread 3 finished phase2 Thread 0 finished phase2 Thread 4 finished phase2
也可以像CyclicBarrier一样，当满足某个条件时才开始工作，例如：
final Phaser phaser = new Phaser(5);
phaser.register();
for(int i = 0;i<5;i++){
new Thread("Thread "+i){
public void run() {
System.out.println(getName()+" are ready");
phaser.arriveAndAwaitAdvance();
System.out.println(getName()+" finished phase1");
phaser.arriveAndAwaitAdvance();
System.out.println(getName()+" finished phase2");
}
}.start();
}
System.out.println("Wait for a moment before start");
Thread.sleep(2000);
phaser.arriveAndDeregister();
一开始可能输出：
Thread 0 are ready Thread 2 are ready Thread 1 are ready Wait for a moment before start Thread 3 are ready Thread 4 are ready
2秒后接着输出：
Thread 3 finished phase1 Thread 0 finished phase1 Thread 2 finished phase1 Thread 4 finished phase1 Thread 1 finished phase1 Thread 1 finished phase2 Thread 3 finished phase2 Thread 4 finished phase2 Thread 2 finished phase2 Thread 0 finished phase2
可以通过重写它的onAdvance()方法来实现在每个阶段结束后执行某个自定义的操作：
final Phaser phaser = new Phaser(5){
@Override
protected boolean onAdvance(int phase, int registeredParties) {
System.out.println("============="+phase+"=============");
return super.onAdvance(phase, registeredParties);
}
};
phaser.register();
for(int i = 0;i<5;i++){
new Thread("Thread "+i){
public void run() {
System.out.println(getName()+" are ready");
phaser.arriveAndAwaitAdvance();
System.out.println(getName()+" finished phase1");
phaser.arriveAndAwaitAdvance();
System.out.println(getName()+" finished phase2");
}
}.start();
}
System.out.println("Wait for a moment before start");
Thread.sleep(2000);
phaser.arriveAndDeregister();
这里在每个阶段的条件满足后插入一段分隔符，输出结果可能为：
Thread 0 are ready Thread 2 are ready Thread 1 are ready Wait for a moment before start Thread 4 are ready Thread 3 are ready =============0============= Thread 3 finished phase1 Thread 1 finished phase1 Thread 2 finished phase1 Thread 0 finished phase1 Thread 4 finished phase1 =============1============= Thread 4 finished phase2 Thread 3 finished phase2 Thread 2 finished phase2 Thread 0 finished phase2 Thread 1 finished phase2