java中控制线程间执行顺序的方法

CyclicBarrier 类

  • #### 意义：让一组线程等待至某种状态后全部执行。
  • #### 内置方法：
1. 两组构造函数
public CyclicBarrier(int parties,Runnable action)
 参数为一组线程的个数，action为达到某种状态后执行的动作
public CyclicBarrier(int parties)
 参数为一组线程的个数
2. 两组等待方法：
public int await() throws InterruptedException, BrokenBarrierException { };
 等待至线程执行完后执行后续动作
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
 等待一定的时间后执行后续动作，不管同一组线程是否执行完成。
  • 用法：
1.声明一个CyclicBarrier对象，控制N个线程为一组进行状态控制，将其传入为一组线程中，再线程中执行任务完成的地方写上await函数进行等待。
public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());   
            }
        });

        for(int i=0;i<N;i++)
            new Writer(barrier).start();//将barrier传入线程并启动线程
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
                //cyclicBarrier.await(10000,TimeUnit.MILLISECONDS);等待定时间长后执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

Thread.join() 方法

  • #### 意义：控制线程间的同步执行。将交替执行的线程变为顺序执行的，再B线程前调用A线程的join函数，意为再A执行完成后执行B线程。
  • #### 方法
    ##### 1. t.join（）//调用线程t在此之前执行完成
    ##### 2. t.join(millseconds)//等待t线程执行，等待时间为**毫秒
  • #### 用法
Thread t1 = new OneThread("X", queue);
Thread t2 = new OneThread("Y", queue);
Thread t3 = new OneThread("Z",queue);

t1.start();
t1.join();
t2.start();//t2执行前t1会执行完成
t2.join();
t3.start();//t3执行前t2会执行完成
t3.join();

　CountDownLatch类

  • #### 意义：计数器的功能，例如再A线程执行前需要执行4个线程，可利用此计数器在4个线程执行完成后再执行

内置方法：

1.构造函数
public CountDownLatch(int count) {  };
 //count为前面所需执行线程数
2.阻塞函数：
public void await() throw InterruptedException{};
//等待至count为0开始执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException{}
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  
//将count值减1