java初入多线程9

ReadWriteLock 多写锁

1. ReadWriteLock 是JDK5中提供的读写分离锁，读写分离可以有效的帮助减少锁竞争。用来提高系统性能。
   读写锁的访问约束情况

• 读读 之间不互斥：读读之间不阻塞
• 读-写互斥：读阻塞写，写也会阻塞读
• 写- 写 互斥： 写写堵塞。

public class ReadWriteLockDemo {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new  ReentrantReadWriteLock();
    
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock =readWriteLock.writeLock();
    
    private int value ;
    
    
    public Object handleRead(Lock lock) throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);
            return value;
            
        }finally {
            lock.unlock();
        }
    }
    
    public void handleWrite(Lock lock,int index) throws InterruptedException{
        try {
            lock.lock();  //模拟写的操作
            Thread.sleep(1000);
            value=index;
        } finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        final ReadWriteLockDemo  demo= new ReadWriteLockDemo();
        Runnable readRunnable =new Runnable() {
            
            public void run() {
                try {
//                  demo.handleRead(readLock);
                    demo.handleRead(lock);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
            }
        };
        
        Runnable writerRunnable =new Runnable() {
            
            public void run() {
                try {
//                  demo.handleWrite(writeLock, new Random().nextInt());
                    demo.handleWrite(lock, new Random().nextInt());
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
            }
        };
        
        for (int i = 18; i < 20; i++) {
            new Thread(writerRunnable).start();
        }
    }
    
}

• 在代码中我们使用了两种方式 如果使用读写锁的该程序执行可以在2秒内执行完毕，但是如果是lock锁的没有进行多写分离，那么会在将近20秒的时间内完成。为什么会这么长时间 ，是因为所有的读线程与写线程之间 必须都互相等待 ，导致的。读写分离之后 读读之间不用互相等待 ，大大减少时间。

倒计时器：CountDownLatch

• CountDownLatch 是一个非常实用的多线程控制工具类。主要是用来控制线程等待，它可以让某一个线程等待到知道倒计时结束再开始执行。代码演示如下：

public class CountDownLatchDemo implements Runnable {

    static final CountDownLatch end = new  CountDownLatch(10);
    static final CountDownLatchDemo  demo = new CountDownLatchDemo();
    
    
    @Override
    public void run() {
        
        try {
            
            //模拟检查任务 
            Thread.sleep(new Random().nextInt(10)*1000);
            System.out.println("check complete");
            end.countDown();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

    public static void main(String[] args) throws Exception {
        ExecutorService exec = new  ThreadPoolExecutor(10, 10,
                  0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>());
        for(int i = 0 ; i < 10 ; i++){
            exec.submit(demo);
        }
        
        //等待检查
        end.await();
        
        // 发射  相当于开始执行任务
        System.out.println("fire");
        
        exec.shutdown();
    }
}

• 在上述代码中 计数器数量为10 ，那么就是需要有10个线程完成任务，在CountDownLatch 上的线程才能继续执行。 在代码中我们能看到有个countdown()方法， 就是用来通知CountDownLatch， 如果一个线程完成任务，那么倒计时器就可以减1.。 我们在await 方法，要求主线程等待所有10个检查任务全部完成，那么主线程才会继续执行。

循环栅栏 ：CyclicBarrier

• 这是一种不同于 CountDOwnLatch 的多线程并发控制工具，但是也可以实现线程间的计数等待。它比CountDownLatch 功能更加强大且复杂。
• 循环栅栏 意思就是循环，如果我们使用的是其计数器的功能那么如果是20个，等到计数器归0 之后还会凑齐下一批20个线程，再次形成栅栏。代码如下：

public class CyclicBarrierDemo {
        
    
    public static class Soldier implements Runnable{
        private String soldier;
        private final  CyclicBarrier cyclic ;
        
        public Soldier( CyclicBarrier cyclic , String soldier) {
            this.cyclic = cyclic ;
            this.soldier = soldier ;
        }
        
        @Override
        public void run() {
            try {
                //等到所有任务的到来
                cyclic.await() ;
                doWork();
                
                //等待所有任务完成
                cyclic.await();
                
            } catch (Exception e) {
                // TODO: handle exception
            }
            
        
        }
        
        void doWork(){
            try {
                Thread.sleep(Math.abs(new Random().nextInt()%10_000));
                
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
    }
    
    public static class BarrierRun implements Runnable {
        boolean flag ;
        int  N ;
        public BarrierRun(boolean flag, int n) {
            this.flag = flag;
            N = n;
        } 
        
        @Override
        public void run() {
            if(flag){
                System.out.println("司令 ： 士兵"+ N + "个,任务完成");
            }else{
                System.out.println("司令 ： 士兵"+ N + "个,集合完毕");
            }
            
        }
        
        
    }
    public static void main(String[] args) {
        final int N = 10 ;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false ; 
        CyclicBarrier cyclic =new CyclicBarrier(N, new BarrierRun(flag, N));
        
        //设置屏障点,主要是为了执行这个方法
        System.out.println("集合队伍！");
        
        for(int i = 0 ; i < N ; i++ ){
            System.out.println("士兵 "+ i + " 报道 ");
            allSoldier[i] = new  Thread(new Soldier(cyclic, " 士兵 " + i));
            allSoldier[i].start();
        }
        
    }
}

• 根据代码中，我们可以发现 执行await 方法的时候 可能会抛出异常， 一个是等待异常InterruptedException，这个是方便相应 外部紧急事件，另外一个异常是BrokenBarrierException ，这个表示 CyclicBarrier 已经损坏， 系统没法等到所有线程然后再开始执行，处理是把所有线程中断 。就避免 线程的永久的等待了

  
  执行结果

• 整个过程的流程图如下：

  
  示意图