public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(4);
        for(int i = 0;i < latch.getCount();i++){
            new Thread(new MyThread(latch),"player" + i).start();
        }
        System.out.println("等待 所所有玩家 准备好");
        latch.await();
        System.out.println("开始游戏");
    }


    private static class MyThread implements Runnable{
        private CountDownLatch latch;

        public MyThread(CountDownLatch latch){
            this.latch = latch;
        }
        @SneakyThrows
        @Override
        public void run() {

            Random rand = null;
            try {
                rand = new Random();
                int randomNum = rand.nextInt((3000 - 1000)  +1 ) + 1000;
                Thread.sleep(randomNum);
                System.out.println(Thread.currentThread().getName() + "已经准备好 " + "所使用的时间是：" + randomNum );
                latch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3);
        for(int i = 0; i < barrier.getParties(); i++){
            new Thread(new MyRunnable(barrier), "队友"+i).start();
        }
        System.out.println("main function is finished.");
    }


    private static class MyRunnable implements Runnable{
        private CyclicBarrier barrier;

        public MyRunnable(CyclicBarrier barrier){
            this.barrier = barrier;
        }

        @Override
        public void run() {
            for(int i = 0; i < 3; i++) {
                try {
                    Random rand = new Random();
                    int randomNum = rand.nextInt((3000 - 1000) + 1) + 1000;//产生1000到3000之间的随机整数
                    Thread.sleep(randomNum);
                    System.out.println(Thread.currentThread().getName() + ", 通过了第"+i+"个障碍物, 使用了 "+((double)randomNum/1000)+"s");
                    this.barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/**
 * @author devin
 * @version 1.0.2
 * @date 2021-02-16 23:23
 */
public class Zhenze {
    // 待匹配字符串

    public static void main(String[] args) {
        String str = "湖北省武汉市1573rr4562";
        Pattern  p = Pattern.compile("[1-9]+");
        Matcher m = p.matcher(str);
        while(m.find()){
            System.out.println(m.group());
        }
    }

}

/**
 *  
 *  @author devin
 *  @date 2021-01-08 11:12
 *  @version 1.0.2
*/
public class SingleTest {

    private static volatile SingleTest instance;

    private SingleTest(){
        System.out.println("create method");
    }

    //在这里加同步太重
    public static  SingleTest getInstance(){
        if(instance == null){
            synchronized (SingleTest.class){
                if(instance == null){
                    return instance = new SingleTest();
                }
            }
        }

        return instance;

    }

    public static void main(String[] args) {
        for(int i = 0;i < 1000;i++){
            new Thread(){
                @Override
                public void run() {
                    SingleTest.getInstance();
                }
            }.start();
        }

    }
}

/**
 * @author devin
 * @version 1.0.2
 * @date 2021-01-13 20:48
 */
public class Demo2 {
    private static final int _512KB = 512 * 1024;
    private static final int _1MB = 1024 * 1024;
    private static final int _6MB = 6 * 1024 * 1024;
    private static final int _7MB = 7 * 1024 * 1024;
    private static final int _8MB = 8 * 1024 * 1024;

    // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc

    public static void main(String[] args) throws InterruptedException {

        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);
        queue.add(2);
        queue.add(3);
        queue.add(5);
        queue.put(3);
        System.out.println(queue.take());
    }

}

class ThreadB2 extends Thread {

    /**
     * 线程 BBB 持有对象锁 this，即当前对象 threadB2
     */
    @Override
    public void run() {
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + " beg "
                    + System.currentTimeMillis());
            System.out.println("B2 ing");
            System.out.println(Thread.currentThread().getName() + " end "
                    + System.currentTimeMillis());
        }
    }
}

class ThreadA2 extends Thread {

    private ThreadB2 threadB2;

    public ThreadA2(ThreadB2 threadB2) {
        this.threadB2 = threadB2;
    }

    /**
     * 线程 AAA 持有对象锁 threadB2
     */

    @Override
    public void run() {
        //B2 被锁住
        synchronized (threadB2) {
            System.out.println(Thread.currentThread().getName() + " beg "
                    + System.currentTimeMillis());
            try {
                System.out.println("wait之前：" + threadB2.isAlive());
                threadB2.wait();
                System.out.println("wait之后：" + threadB2.isAlive());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            try {
//                Thread.sleep(2000);
//            } catch (InterruptedException e) {
//            }
            System.out.println(Thread.currentThread().getName() + " end "
                    + System.currentTimeMillis());
        }
    }
}

class Run2 {

    public static void main(String[] args) {
        ThreadB2 threadB2 = new ThreadB2();
        threadB2.setName("B2");
        ThreadA2 threadA2 = new ThreadA2(threadB2);
        threadA2.setName("A2");



        threadA2.start();
        threadB2.start();
    }

}