Java中间件(2)--分布式系统&中间件从入门到精通（六）

上篇文章介绍了线程池使用的优点，synchronized和reentrantLock的区别，reentrantlock又有读写锁，适用于读多写少的场景，可以用tryLock获取锁，并且在构造器可以指定布尔值，来当做公平锁来使用。

Java中间件(1)--分布式系统&中间件从入门到精通（五）https://blog.csdn.net/ke1ying/article/details/122582076

前面说了synchronized除了有互斥性的作用外，还有可见性的作用，synchronized保证了代码块中变量的可见性，Volatile则保证了所修饰变量的可见性，是实现轻量级变量可见性方法。直接在变量前面加个volatile关键字就行。

需要注意的是，与锁相比，这里只操作了线程的可见性，绝对没有保证原子性，可见性和多个线程操作变量保证互斥性是两件事，如果volatile修饰的变量，在多线程的情况下来操作数据，并不能保证线程安全问题。

Atomics是jdk1.5之后引入的，这里面会有一些atomic开头的类，比如int在这里会显示AtomicInteger来提供相关原子性的操作，不光保证原子性，性能也能得到提升，主要因为atomicInteger内部通过JNI的方式使用硬件支持cas指令。

而wait、notify、notifyAll则是java的Object对象上的三个方法，这三个的调用都必须写在synchronized代码块里，顾名思义wait是等待的，后面两个则会唤醒它，notify是单个唤醒，notifyAll则是唤醒所有。

在代码实践中，wait的使用一般嵌在循环中，当达到一定值的时候，会判断是否到达，如果没有则继续等待，这么做主要为了防止虚假唤醒。

countdownLatch也是current包里的一个类，主要是当多个线程达到预期状态，多个线程这里指的是初始化countDownLatch里的参数，其他线程才可以从等待状态继续运行，即是可以唤醒多个等待的线程，达到自己的预期会调用countDown方法，而等待的线程则会调用await（）方法，当参数一直到0的时候，则会调用notifyAll()方法，让等待线程不再等待。

       int max = 100;
       
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(100, 100, 60L,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(max));
        //AtomicInteger atomicInteger = new AtomicInteger();
        CountDownLatch countDownLatch = new CountDownLatch(max);
      
        for (int i = 0; i < max; i++) {
            threadPoolExecutor.execute(() -> {
                //atomicInteger.incrementAndGet();
                try {
                    countDownLatch.countDown();
                 
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });

        }
   
        System.out.println("子线程运行中=========");
        // countDownLatch.await();
        threadPoolExecutor.shutdown();
        System.out.println("子线程运行完才会输出！！！");

cyclicBarrier使用和countDownLatch类似，但是他是可以循环使用的，而且线程池数量太少容易发生死锁一定要小心最大线程数，使用的时候，参数必须任务数+1,因为countDownLatch调用的是countDown减一，然后调用await等待，而cyclicBarrier则是所有都调用await，当所有子线程和主线程都到达那个点阻塞的时候，这时候才会进行下一步。

        int max = 100;
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(100, 100, 60L,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(max));
        //AtomicInteger atomicInteger = new AtomicInteger();
        //CountDownLatch countDownLatch = new CountDownLatch(max);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(max + 1);
        for (int i = 0; i < max; i++) {
            threadPoolExecutor.execute(() -> {
                //atomicInteger.incrementAndGet();
                try {
                    //countDownLatch.countDown();
                    System.out.println(Thread.currentThread().getName());
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });

        }
       
        System.out.println("子线程运行中=========");
        cyclicBarrier.await();
        // countDownLatch.await();
        threadPoolExecutor.shutdown();
        System.out.println("子线程运行完才会输出！！！");