Java多线程之----Phaser
Phaser类的功能和CyclicBarrier、CountDownLatch的有很多类似的地方，例如线程互相等待，等待某个线程完成再进行其他任务，这在Phaser都可以实现，而Phaser却更加的灵活，因为它可以动态的注册线程数量，取消注册数量，这可以给我们带来更多的控制。
Phaser有几个重要的方法：
1.arrive:该方法简单的说就是记录到达的线程数，有点像CountDownLatch的countDown，该方法调用后不会等待其他线程
2.arriveAwaitAdvance:该方法和arrive一样，但是该方法调用会等待其他未到达的线程
3.arriveAndDeregister:该方法和arrive一样，但是该方法调用后会减少注册的数量
4.register:该方法可以动态的注册一个线程数量
有如下情景：学生进行考试，需要全部考生都考完之后才可以离场，代码如下：
public class PhaserTest1 {
public static void main(String[] args) {
Phaser phaser = new Phaser(5);
for (int i = 0; i < 5; i++) {
new Thread(new Student(phaser, "考生" + i)).start();
}
}
public static class Student implements Runnable {
private Phaser phaser;
private String name;
public Student(Phaser phaser, String name) {
this.phaser = phaser;
this.name = name;
}
@Override
public void run() {
try {
System.out.println(name + "进入考场，开始考试....");
Thread.sleep((int) (Math.random() * 10) * 1000);
System.out.println(name + "考完,等待其他考生考完后离场");
phaser.arriveAndAwaitAdvance();// 使用该方法会阻塞,直到所有线程都到达这个点程序才继续运行
System.out.println(name + "考生离场....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//考生1进入考场，开始考试....
//考生3进入考场，开始考试....
//考生0进入考场，开始考试....
//考生2进入考场，开始考试....
//考生4进入考场，开始考试....
//考生1考完,等待其他考生考完后离场
//考生0考完,等待其他考生考完后离场
//考生4考完,等待其他考生考完后离场
//考生3考完,等待其他考生考完后离场
//考生2考完,等待其他考生考完后离场
//考生4考生离场....
//考生0考生离场....
//考生2考生离场....
//考生3考生离场....
//考生1考生离场....
如果初始化的时候，传入的是6，那么这5个线程就会一直等待
如果将arriveAndAwaitAdvance改成arrive，那么结果是：
//考生0进入考场，开始考试....
//考生1进入考场，开始考试....
//考生3进入考场，开始考试....
//考生4进入考场，开始考试....
//考生2进入考场，开始考试....
//考生0考完,等待其他考生考完后离场
//考生0考生离场....
//考生1考完,等待其他考生考完后离场
//考生1考生离场....
//考生3考完,等待其他考生考完后离场
//考生3考生离场....
//考生4考完,等待其他考生考完后离场
//考生4考生离场....
//考生2考完,等待其他考生考完后离场
//考生2考生离场....接下来看下arriveAndDeregister方法，修改main方法中的代码，如下
public static void main(String[] args) {
Phaser phaser = new Phaser(6);// 初始化注册线程数量为6
for (int i = 0; i < 5; i++) {// 只有5个线程，如果没有其他操作，那么线程会一直阻塞
new Thread(new Student(phaser, "考生" + i)).start();
}
Scanner scanner = new Scanner(System.in);
scanner.nextLine();
phaser.arriveAndDeregister();//调用该方法，减少注册是数量，即6->5，那么原有的5个线程已经满足条件，所有线程继续执行
System.out.println("考试结束");
}考生0进入考场，开始考试....
考生2进入考场，开始考试....
考生4进入考场，开始考试....
考生1进入考场，开始考试....
考生3进入考场，开始考试....
考生0考完,等待其他考生考完后离场
考生4考完,等待其他考生考完后离场
考生2考完,等待其他考生考完后离场
考生3考完,等待其他考生考完后离场
考生1考完,等待其他考生考完后离场
考试结束
考生2考生离场....
考生4考生离场....
考生0考生离场....
考生1考生离场....
考生3考生离场....
接下来再说下register方法
public class PhaserTest2 {
public static void main(String[] args) {
Phaser phaser = new Phaser(1);// 注册了一个线程
for (int i = 0; i < 5; i++) {
new Thread(new Student(phaser, "考生" + i)).start();
}
Scanner scanner = new Scanner(System.in);
scanner.nextLine();
phaser.arriveAndDeregister();
System.out.println("考试结束");
}
public static class Student implements Runnable {
private Phaser phaser;
private String name;
public Student(Phaser phaser, String name) {
this.phaser = phaser;
this.name = name;
}
@Override
public void run() {
try {
phaser.register();// 每个子线程都会注册一次，所有最后一共有6个注册线程
System.out.println(name + "进入考场，开始考试....");
Thread.sleep((int) (Math.random() * 10) * 1000);
System.out.println(name + "考完,等待其他考生考完后离场");
phaser.arriveAndAwaitAdvance();// 使用该方法会阻塞,直到所有线程都到达这个点程序才继续运行
System.out.println(name + "考生离场....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}Phaser还有一个用法，就是重写onAdvance方法。当所有线程都到达了(即使用了arrive、arriveAndAwaitAdvance、arriveAndDeregister方法)，那么就会调用onAdvance方法一次。
该方法有两个参数，一个参数是代表当前是第几个阶段(所有线程到达一次为一个阶段，从0开始)
如果考生需要考语数英3门考试，这3门考试是阶段性的，一门接着一门，那么可以通过重写onAdvance方法，来对每个阶段进行处理，这里只是打印出一条信息
public class PhaserTest3 {
public static void main(String[] args) {
Phaser phaser = new Phaser(5) {
@Override
protected boolean onAdvance(int phase, int registeredParties) {
switch (phase) {
case 0:
System.out.println("所有考生考完数学....");
return false;
case 1:
System.out.println("所有考生考完语文....");
return false;
case 2:
System.out.println("所有考生考完英语....");
return false;
default:
System.out.println("phase:" + phase);
return true;
}
}
};
for (int i = 0; i < 5; i++) {
new Thread(new Student(phaser, "考生" + i)).start();
}
}
public static class Student implements Runnable {
private Phaser phaser;
private String name;
public Student(Phaser phaser, String name) {
this.phaser = phaser;
this.name = name;
}
@Override
public void run() {
try {
System.out.println(name + "：数学考试开始");
Thread.sleep((int) (Math.random() * 10) * 1000);
System.out.println(name + "考完数学,等待其他考生考完后参加下一场考试");
phaser.arriveAndAwaitAdvance();//
System.out.println(name + "：语文考试开始");
Thread.sleep((int) (Math.random() * 10) * 1000);
System.out.println(name + "考完语文,等待其他考生考完后参加下一场考试");
phaser.arriveAndAwaitAdvance();//
System.out.println(name + "：英语考试开始");
Thread.sleep((int) (Math.random() * 10) * 1000);
System.out.println(name + "考完英语,等待其他考生考完后参加下一场考试");
phaser.arriveAndAwaitAdvance();//
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//考生0：数学考试开始
//考生2：数学考试开始
//考生4：数学考试开始
//考生1：数学考试开始
//考生3：数学考试开始
//考生0考完数学,等待其他考生考完后参加下一场考试
//考生4考完数学,等待其他考生考完后参加下一场考试
//考生3考完数学,等待其他考生考完后参加下一场考试
//考生2考完数学,等待其他考生考完后参加下一场考试
//考生1考完数学,等待其他考生考完后参加下一场考试
//所有考生考完数学....
//考生2：语文考试开始
//考生4：语文考试开始
//考生0：语文考试开始
//考生1：语文考试开始
//考生1考完语文,等待其他考生考完后参加下一场考试
//考生3：语文考试开始
//考生3考完语文,等待其他考生考完后参加下一场考试
//考生2考完语文,等待其他考生考完后参加下一场考试
//考生0考完语文,等待其他考生考完后参加下一场考试
//考生4考完语文,等待其他考生考完后参加下一场考试
//所有考生考完语文....
//考生0：英语考试开始
//考生2：英语考试开始
//考生4：英语考试开始
//考生3：英语考试开始
//考生1：英语考试开始
//考生1考完英语,等待其他考生考完后参加下一场考试
//考生2考完英语,等待其他考生考完后参加下一场考试
//考生4考完英语,等待其他考生考完后参加下一场考试
//考生3考完英语,等待其他考生考完后参加下一场考试
//考生0考完英语,等待其他考生考完后参加下一场考试
//所有考生考完英语....好了，Phaser就介绍到这里
参考资料：
http://whitesock.iteye.com/blog/1135457
http://blog.csdn.net/andycpp/article/details/8838820