这次整理了一些比较常用的线程工具类啦。

CountDownLatch：在一组线程执行完后，才能开始执行调用等待的线程。上片文章提到过junit的测试尽量不要测试线程，如果硬是要可以使用CountDownLatch进行测试

CyclicBarrier：在一组线程中调用等待方法后，只有这组所有线程都进入等待后，会执行一个指定的线程，在指定的线程执行完后，这组等待的线程才能继续执行。

Semaphore：可用于限流使用。

Exchanger：当两组线程都执行到交换的方法时，能将数据在这两个线程之间进行数据交换。

CountDownLatch

该类实现主要是由一个内部类Sync实现的，Sync继承了AbstractQueuedSynchronizer(就是经常提到的AQS)，

常用的方法有两个:

1.await():线程调用该方法进入带阻塞状态，只有当调用countDown()并骤减到0的时候，才能继续执行

2.countDown():线程骤减一个单位。

具体实现：

 

public class CountDownLatchMain {static CountDownLatch latch = new CountDownLatch(6);static class InitThread implements Runnable{public void run() {try {TimeUnit.MILLISECONDS.sleep(200L);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("Thread name:"+Thread.currentThread().getName()+" init ...");latch.countDown();}}static class BusinessThread implements Runnable{public void run() {try {latch.await();} catch (InterruptedException e1) {e1.printStackTrace();}for(int i=0;i<3;i++) {try {TimeUnit.MILLISECONDS.sleep(100L);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Thread name : " + Thread.currentThread().getName()+" work_" + i);}}}public static void main(String[] args) throws InterruptedException {new Thread(new Runnable() {public void run() {latch.countDown();System.out.println("thread name "+Thread.currentThread().getName()+" 1st init ...");try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}latch.countDown();System.out.println("thread name "+Thread.currentThread().getName()+" 2nd init ...");}},"Thread-0").start();new Thread(new BusinessThread()).start();for(int i=0;i<=4 ;i++) {new Thread(new InitThread()).start();}latch.await();TimeUnit.MILLISECONDS.sleep(300);System.out.println("main end ...");}
}

 执行结果：

thread name Thread-0 1st init ...
Thread name:Thread-1 init ...
Thread name:Thread-3 init ...
Thread name:Thread-2 init ...
Thread name:Thread-5 init ...
Thread name:Thread-4 init ...
Thread name : Thread-0 work_0
Thread name : Thread-0 work_1
Thread name : Thread-0 work_2
main end ...
thread name Thread-0 2nd init ...

CyclicBarrier

 

与CountDownLatch差不多，都是等待线程执行完后，才能继续执行，不过这两个不同的地方就是：CountDownLatch需要手动在逻辑代码中进行骤减，减到临界点后，阻塞的线程会继续执行，而CountDownLatch是一组线程都进入到阻塞状态后，然后执行指定线程执行完后，那组阻塞的线程才能继续执行。 示例：

public class CyclicBarrierMain {static CyclicBarrier barrier = new CyclicBarrier(5,new Runnable() {public void run() {System.out.println("Thread name : " + Thread.currentThread().getName() + " barrier start...");try {TimeUnit.MILLISECONDS.sleep(100L);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("Thread name : " + Thread.currentThread().getName() + " barrier thread ...");}});static class SubThread implements Runnable{public void run() {long sleep = (long) (Math.random()*1000);System.out.println("thread name : " + Thread.currentThread().getName() + " init ...");try {TimeUnit.MILLISECONDS.sleep(sleep);} catch (InterruptedException e) {e.printStackTrace();}try {System.out.println("thread name : " + Thread.currentThread().getName() + " sleep time:"+sleep);barrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}System.out.println("thread name : " + Thread.currentThread().getName() + " end ....");}}public static void main(String[] args) {for(int i =0 ; i<5;i++) {new Thread(new SubThread()).start();}}
}

执行结果：

thread name : Thread-2 init ...
thread name : Thread-4 init ...
thread name : Thread-1 init ...
thread name : Thread-0 init ...
thread name : Thread-3 init ...
thread name : Thread-2 sleep time:405
thread name : Thread-0 sleep time:488
thread name : Thread-1 sleep time:564
thread name : Thread-4 sleep time:777
thread name : Thread-3 sleep time:860
Thread name : Thread-3 barrier start...
Thread name : Thread-3 barrier thread ...
thread name : Thread-3 end ....
thread name : Thread-2 end ....
thread name : Thread-1 end ....
thread name : Thread-0 end ....
thread name : Thread-4 end ....

Semaphore

 

主要用于需要做限制的场景，比如限制连接池获取次数等等，也有一个Sync内部类继承了AQS

常用方法：

1、acquire():骤减一个单位，也可调用带参的方法可指定减值，当骤减到0的时候，调用该方法会进入阻塞状态。

2、release():释放一个单位，也会在初始化的数量进行增加。

3、availablePermits():得到可获取单位的数量。

4、getQueueLength()：调用了acquire()方法并进入到阻塞状态的总数量。

具体用法：

Semaphore semaphore = new Semaphore(5);
semaphore.acquire();//也可指定减少多个semaphore.acquire(2);
//...第6个acquire()方法时,再次调用将进入等待，直到在某个线程中执行了semaphore.release()方法才会继续执行后面的
//...

Exchanger

主要用于两个线程之间的数据交换，个人觉得这个用处不大，既然看到了这个，也就顺便整理了一下

使用示例：

public class UseExcahnger {static Exchanger<Set<String>> exchanger = new Exchanger<Set<String>>();static class ThreadOne extends Thread{@Overridepublic void run() {Set<String> set = new HashSet<String>();set.add("1");set.add("2");try {System.out.println(Thread.currentThread().getName() + " > set:" + set);Thread.sleep(2000L);Set<String> exchange = exchanger.exchange(set);System.out.println(Thread.currentThread().getName() + " > " + exchange);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}static class ThreadTwo extends Thread{@Overridepublic void run() {Set<String> set = new HashSet<String>();set.add("3");set.add("4");try {System.out.println(Thread.currentThread().getName() + " > set:" + set);Thread.sleep(3000L);Set<String> exchange = exchanger.exchange(set);System.out.println(Thread.currentThread().getName() + " > " + exchange);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {new ThreadOne().start();new ThreadTwo().start();}
}

执行结果为：

Thread-0 > set:[1, 2]
Thread-1 > set:[3, 4]
Thread-1 > [1, 2]
Thread-0 > [3, 4]

Future/FutureTask

这个在之前的提到过，与Callable一起使用，用来做回调的，个人觉得这个与之前的Fork/Join的分而治之有些相似，都是异步同时执行完后将结果返回，然后发现相似之后，回去看了一下源代码

RecursiveAction和RecursiveTask<T> 都分别继承了Future接口，而FutureTask也继承了Future、Runnable，所以FutureTask既能作为Callable带有返回结果，也能作为Thread去执行它。

这里就介绍一下类中的一些方法，示例的话可以翻看之前的文章

1、isDone()：判断线程是否已结束。

2、boolean cancel(boolean mayInterruptIfRunning)：参数为true是中断线程，但是只会发送中断信号，在程序中需要自行判断，参数为false则不会中断，返回值为true，如果线程已结束或未开始则返回false。

3、isCancelled()：判断线程是否关闭。

4、get()：获取线程返回值。

好啦，就先整理这些啦，后面还有一些还在整理，后期会继续分享的呀，如果有问题烦请各路大佬指出