【多线程】四种种方案实现多线程之间相互协作的通信

在并发编程中，经常会遇到多个线程之间需要相互协作的情况，即并不是多个线程同时执行，而是按照一定的顺序循环执行的情况。
那么怎样去实现这种效果呢？这里介绍三种方案。
这里都以子线程循环10次，然后主线程循环10次，然后往复循环50次的思路来做例子。在下面的例子中flag代表一个共享变量。

一、synchronized+notify+wait+flag

public class communication01 {
    public static void main(String[] args){
        final besiness b=new besiness();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=50;i++){
                    b.sub(i);
                }
            }
        }).start();

        for (int i = 1; i <= 50; i++) {
            b.main(i);
        }

    }
}
    class besiness{
        private static  boolean flag=true;//flag为true时允许main访问，为false时允许suB访问
        public synchronized void main(int i){
            while(!flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int j = 1; j <= 10; j++) {
                System.out.println("main thread==" + j + ",loop of " + i);
            }
            flag=false;
            this.notify();

        }
        public  synchronized  void sub(int i){
            while (flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int j = 1; j <= 10; j++) {
                System.out.println("sub thread==" + j + ",loop of " + i);
            }
            flag=true;
            this.notify();
        }
    }

这种方案是通过对两个线程中分别要执行的方法加锁synchronized，保证每次执行main时不被sub打断，执行sub循环时，不被main打断。
这里采用了对象object的notify和wait来实现线程之间的通信。当main方法执行完成后，让执行main方法的线程等待，
等待sub方法执行完成后，通知(notify)main线程然后继续执行。这种方式有一个缺点，由于notify和wait使用的是Object的方法，
所以不能单独的让某个特定的线程收到通知或者让他等待，而在存在多个线程同时等待时，只能通过notifyAll来通知所有的线程。不够灵活。

二、lock+condition+flag

 public static void main(String[] args){
        final besiness b=new besiness();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=50;i++){
                    b.sub2(i);
                }

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=50;i++){
                    b.sub3(i);
                }

            }
        }).start();
        for (int i = 1; i <= 50; i++) {
            b.main(i);
        }

    }

   static  class besiness{
        private   int flag=1;//flag为true时允许main访问，为false时允许suB访问
		//condition1来控制main和sub2之间的循环通信
       Condition condition1=lock.newCondition() ;
       //condition2来控制sub2和sub3之间的循环通信
       Condition condition2=lock.newCondition() ;
       //condition1来控制main和sub3之间的循环通信
       Condition condition3=lock.newCondition() ;
        public  void main(int i){
            lock.lock();
            try{
                while(flag!=1){
                    try {
                        condition1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                for (int j = 1; j <= 20; j++) {
                    System.out.println("main thread==" + j + ",loop of " + i);
                }
                flag=2;
                condition2.signal();
            }finally {
                lock.unlock();
            }
        }
        public    void sub2(int i){
            lock.lock();

            try{
                while ( flag !=2){
                    try {
                        condition2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                for (int j = 1; j <= 20; j++) {
                    System.out.println("sub2 thread==" + j + ",loop of " + i);
                }
                flag=3;
                condition3.signal();
            }finally {
                lock.unlock();
            }
        }

       public    void sub3(int i){
           lock.lock();

           try{
               while ( flag !=3){
                   try {
                       condition3.await();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               for (int j = 1; j <= 20; j++) {
                   System.out.println("sub3 thread==" + j + ",loop of " + i);
               }
               flag=1;
               condition1.signal();
           }finally {
               lock.unlock();
           }
       }
    }

这种方式是利用了Java5中提供的lock和condition，利用共享变量flag来实现线程之间的相互通信。同时在这个小例子中，相比上一个例子中增加了一个线程的循环。这是为了体现使用condition的优点。
使用condition可以非常灵活的去控制线程与线程之间的通信。因为在一个类中可以创建多个condition的实例，
我们可以通过condition不同的实例的signal和await方法来标识不同的两个线程之间相互通信的标识，而不是统一使用object的notify和wait方法了。
同时利用lock方法可以利用锁的重入机制实现更加灵活的锁的应用。可以在需要的时候加锁或解锁。
这样我们就可以实现多个线程之间的协调通信了。

三、semaphere+flag

    public static void main(String[] args){
        final besiness b=new besiness();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=50;i++){
                    b.sub(i);
                }
            }
        }).start();

        for (int i = 1; i <= 50; i++) {
            b.main(i);
        }

    }
   static class besiness{
        private  int  flag=1;
       final Semaphore sp=new Semaphore(1);//声明一个信号，共享一个资源，每次只能允许一个线程执行
        public  void main(int i){

            try {
                sp.acquire();

                while(flag!=1){
                    sp.release();

                }

                for (int j = 1; j <= 10; j++) {
                    System.out.println("main thread==" + j + ",loop of " + i);
                }
                flag=2;

            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                sp.release();
            }


        }

        public   void sub(int i){
            try{
                try {
                    sp.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while (flag !=2){

                    sp.release();
                }
                for (int j = 1; j <= 10; j++) {
                    System.out.println("sub thread==" + j + ",loop of " + i);
                }
                flag=1;
                sp.release();
            }finally {
                sp.release();
            }

        }
    }

这里semaphere代表一个信号量，它可以指示共享资源的个数，也就是同时访问资源的线程个数。这里主要通过semaphere的acquire和release实现锁的功能从而实现线程之间的通信。
利用semaphere不仅可以实现多个线程协调循环通信，在必要时还可以控制同一时间访问资源的个数。更加的灵活和方便。

四、countdownLatch

package com.jihite;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {
    private static final int RUNNER_COUNT = 10;
    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch begin = new CountDownLatch(1);
        final CountDownLatch end = new CountDownLatch(RUNNER_COUNT);
        final ExecutorService exec = Executors.newFixedThreadPool(10);

        for (int i = 0; i < RUNNER_COUNT; i++) {
            final int NO = i + 1;
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    try {
                        begin.await();
                        Thread.sleep((long)(Math.random() * 10000));
                        System.out.println("No." + NO + " arrived");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        end.countDown();
                    }
                }
            };
            exec.submit(run);
        }

        System.out.println("Game Start ...");
        begin.countDown();
        end.await();
//        end.await(30, TimeUnit.SECONDS);
        System.out.println("Game Over.");

        exec.shutdown();
    }
}

以上是实习多个线程之间相互协调通信的几种方案。