public class Demo01 {
    //public static Map<String,String> maps = new HashMap<String, String>();
    //public static Map<String,String> maps = new Hashtable<String, String>();
    public static Map<String,String> maps = new ConcurrentHashMap<String, String>();
    public static void main(String[] args) throws Exception {
        Runnable task = new Temp();
        Thread t1 = new Thread(task,"A線程");
        Thread t2 = new Thread(task,"B線程");
        t1.start();
        t2.start();
        // 保證t1和t2先執(zhí)行完
        t1.join();
        t2.join();
        System.out.println("最終集合長(zhǎng)度："+maps.size());
    }
}
class Temp implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 500000; i++) {
 Demo01.maps.put(Thread.currentThread().getName()+i,Thread.currentThread().getName()+i);
        }
    }
}

// 創(chuàng)建CountDownLatch
CountDownLatch cdl = new CountDownLatch(1);
cdl.await()// 讓出cpu，使當(dāng)前線程等待
cdl.CountDown() // 計(jì)數(shù)器減1，只有當(dāng)計(jì)數(shù)器為零時(shí)才會(huì)喚醒被await的線程

public class Demo02 {
    public static void main(String[] args) {
        CountDownLatch count = new CountDownLatch(1);
        new ThreadA(count).start();
        new ThreadB(count).start();
    }
}
class ThreadA extends Thread{
    private CountDownLatch count;
    public ThreadA(CountDownLatch count) {
        this.count = count;
    }
    @Override
    public void run() {
        System.out.println("A");
        // 使當(dāng)前線程等待  等待打印B之后宰繼續(xù)執(zhí)行打印A
        try {
            count.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("C");
    }
}
class ThreadB extends Thread{
    private CountDownLatch count;
    public ThreadB(CountDownLatch count) {
        this.count = count;
    }
    @Override
    public void run() {
        System.out.println("B");
        // 當(dāng)前線程執(zhí)行完后倒計(jì)數(shù)減一
        count.countDown();
    }
}

// 六條線程：五個(gè)員工進(jìn)入會(huì)議室、一個(gè)開會(huì)
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // 創(chuàng)建循環(huán)屏障
        CyclicBarrier cb = new CyclicBarrier(5,new Metting());
        for (int i = 1; i <= 4; i++) {
            new Employee(i+"號(hào)員工",cb).start();
        }
    }
}
class Employee extends Thread{
    private CyclicBarrier cb;
    public Employee(String s, CyclicBarrier cb) {
        super(s);
        this.cb = cb;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"進(jìn)入會(huì)議室");

        try {
            Thread.sleep(1000);
            cb.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Metting implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"組織會(huì)議,會(huì)議開始");
    }
}

CyclicBarrier cb = new CyclicBarrier(5,new Metting());

public Semaphore(int permits) // permits為允許執(zhí)行的線程數(shù)
public Semaphore(int permits, boolean fair)
    // fair為true表示公平鎖，等待時(shí)間最長(zhǎng)的線程將在下次進(jìn)入 反之是不公平鎖

public void acquire()  // 表示獲得許可
public void release()  // 表示釋放許可

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 創(chuàng)建任務(wù)
        Service service = new Service();
        for (int i = 1; i <= 5; i++) {
            new MyThread(i+"號(hào)線程",service).start();
        }
    }
}
// 線程類
class MyThread extends Thread{
    private Service service;
    public MyThread(String name,Service service){
        super(name);
        this.service = service;
    }
    @Override
    public void run() {
        try {
            service.testMethod();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
// 抽離業(yè)務(wù)代碼
class Service{
    // 創(chuàng)建Semaphore對(duì)象 并指定線程數(shù)
    private Semaphore sp = new Semaphore(2);
    public void testMethod() throws Exception {
        // 獲取許可
        sp.acquire();
        System.out.println(Thread.currentThread().getName()+"進(jìn)入  時(shí)間："+System.currentTimeMillis());
        Thread.sleep(200);
        System.out.println(Thread.currentThread().getName()+"執(zhí)行成功");
        System.out.println(Thread.currentThread().getName()+"離開  時(shí)間："+System.currentTimeMillis());
        // 釋放許可
        sp.release();
    }
}

public class ExchangerDemo {
    public static void main(String[] args) {
        // 創(chuàng)建交換者
        Exchanger<String> exchanger = new Exchanger<>();
        // 創(chuàng)建兩條線程進(jìn)行交換數(shù)據(jù)
        new ThreadN("線程N(yùn)",exchanger).start();
        new ThreadP("線程P",exchanger).start();
    }
}
class ThreadN extends Thread{
    private Exchanger<String> exchanger;
    public ThreadN(String name,Exchanger<String> exchanger) {
        super(name);
        this.exchanger = exchanger;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"給線程P："+"我是線程N(yùn)");
        try {
            String exchange = exchanger.exchange("我是線程N(yùn)");
            System.out.println("線程N(yùn)拿到數(shù)據(jù)："+exchange);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}
class ThreadP extends Thread{
    private Exchanger<String> exchanger;
    public ThreadP(String name,Exchanger<String> exchanger) {
        super(name);
        this.exchanger = exchanger;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"給線程N(yùn)："+"我是線程P");
        try {
            String exchange = exchanger.exchange("我是線程P");
            System.out.println("線程P拿到數(shù)據(jù)："+exchange);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public V exchange(V x, long timeout, TimeUnit unit)
    // timeout等待的時(shí)間數(shù)值  unit時(shí)間單位
    // 示例：只等待五秒
exchanger.exchange("111","5000", TimeUnit.SECONDS)