JAVA同時プログラミングのマルチスレッド同時同期ビジネスシーンとソリューション

JAVA同時プログラミングのマルチスレッド同時同期ビジネスシーンとソリューション
業務需要1:20人が駅に行って汽車の切符を買うが、2つの窓口しかなく、コントロールが必要で、同時に切符を買うのは2人しかいない.2人のうちいずれかが切符を買って離れた後、待っていた18人のうち1人が窓口で切符を買うことができます.分解:20人が20スレッドではないか.2つのウィンドウがリソースです.実際の意味:同じ時間をどのように制御するかの同時数は2である.Semaphore信号量(同時スレッド数制御):適用シーン:1.ストリーム制限;2.リソースアクセス制御(データベース接続、プリンタのインタフェース)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    /**
     *      ，           
     */
    class SemaphoreRunnable implements Runnable {
        private Semaphore semaphore;  //   
        private int user; //       
        public SemaphoreRunnable(Semaphore semaphore, int user) {
            this.semaphore = semaphore;
            this.user = user;
        }
        @Override
        public void run() {
            try {
                //       
                semaphore.acquire();
                System.out.println("  "+ user +"    ，    ");
                Thread.sleep((long)(Math.random()*10000));
                System.out.println("  "+ user +"    ，    ");
                Thread.sleep((long)(Math.random()*10000));
                System.out.println("  "+ user +"    ");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void execute(){
        //      
        final Semaphore semaphore = new Semaphore(2);
        //   
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //  20     
        for(int i = 0; i < 20 ;i ++) {
            //   
            threadPool.execute(new SemaphoreRunnable(semaphore,(i+1)));
        }
        threadPool.shutdown();;
    }

    public static void main(String[] args) {
        SemaphoreDemo semaphoreDemo = new SemaphoreDemo();
        semaphoreDemo.execute();
    }
}

业务需要2:会社は周末の会食を组织して食事をして、まず従业员达はそれぞれ家から会食の场所まで、すべてそろってから、やっといっしょに食べ物を食べ始めます.
CyclicBarrierシーン:マルチスレッドでデータを計算した後、結果をマージする必要があります.

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //3    
        final CyclicBarrier cb = new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                System.out.println("      ，    。。。。");
            }
        });
        ExecutorService threadPool = Executors.newCachedThreadPool();
       //      
        for(int i = 0; i < 3; i++) {
           final int user = i + 1;
            Runnable r = new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep((long)(Math.random()*10000));
                        System.out.println(user + "      ，    " + (cb.getNumberWaiting() + 1)+"   ");
                        //  
                        cb.await();
                        if(user == 1)
                            System.out.println("    ，    。。。");
                        Thread.sleep((long)(Math.random()*10000));
                        System.out.println(user + "   ，    。。。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            };
            threadPool.execute(r);
        }
        threadPool.shutdown();
    }
}

業務需要3:誘拐事件、目的はお金で人を贖うために張三グループがジョーを誘拐し、1000万人を贖うと言って、張三グループと大ジョーは同時に約束の場所に着いて、それから片手でお金を払って、片手で人を渡す2つのスレッドです.同じポイント(ブロックポイント)で、交換データExchangerの2つのスレッドがデータを交換するシーン:1.2つのスレッドでデータを交換する2.校正作業

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerDemo {
    public static void main(String[] args) {
        //   ，  String  
        Exchanger ec = new Exchanger();
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //    
        threadPool.execute(new Runnable(){

            @Override
            public void run() {
                try {
                    String returnStr = ec.exchange("  ");
                    System.out.println("         ：" + returnStr);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //  
        threadPool.execute(new Runnable(){

            @Override
            public void run() {
                try {
                    String returnStr = ec.exchange("1000 ");
                    System.out.println("   1000    ：" + returnStr);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        threadPool.shutdown();

    }
}

CountDownLatchカウントダウンカウンタには、他のいくつかのタスクが実行されるまで待つ必要があるタスクがあります.

import java.util.concurrent.CountDownLatch;

import static com.google.common.collect.ComparisonChain.start;

public class CountDownLatchDemo {

    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);
        //  1
        new Thread(){
            public void run() {
                try {
                    System.out.println("  1      ...");
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("  1    ...");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread(){
            public void run() {
                try {
                    System.out.println("  2      ...");
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("  2    ...");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        //   
        System.out.println("    2       ，          " + Thread.currentThread().getName() );
        try {
            latch.await();
            System.out.println("          ，       ：" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}