Java 并发编程 四 协作

## 1、ReadWriteLock读写锁

概念很好理解，下面是代码：

package com.test.thread3;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteReentrantLockTest   {

    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 ReadWriteReentrantLockTest demo = new ReadWriteReentrantLockTest();

        Runnable read = new Runnable() {
            public void run() {
                try {
                    //demo.handleRead(lock);
                int i=   (Integer) demo.handleRead(readLock);
                System.out.println("read:"+i);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        };

        Runnable write = new Runnable() {
            public void run() {
                try {
                    int i = new Random().nextInt();
                    System.out.println(Thread.currentThread().getId()+" i "+i);
                demo.handleWrite(WriteLock, i);
            //   demo.handleWrite(lock, new Random().nextInt());
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        };


        for(int i=0;i<18;i++){
            new Thread(read).start();
        }

        for(int i=18;i<20;i++){
            new Thread(write).start();
        }

        try {
            Thread.sleep(3000);
            System.out.println(demo.value);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }



}

可以观察到使用普通的ReetrantLock 和 ReentrantReadWriteLock执行时间的区别。

##2、倒计时器 CountDownLatch

CountDownLatch 是一个非常使用的多线程控制工具类。CountDown 在英文中意为倒计数，Latch是门闩的意思。 门闩的含义是：把门锁起来，不让里面的线跑出来。因此这个歌工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

public class CountDownLatchDemo implements Runnable {

    static final CountDownLatch end = new CountDownLatch(10);
    static final CountDownLatchDemo demo = new CountDownLatchDemo();

    public void run() {

        try {
            Thread.sleep(new Random().nextInt(10) * 1000);
            System.out.println("check complete");
            end.countDown();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

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

        ExecutorService exec = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            exec.submit(demo);
        }
        end.await();
        System.out.println("Fire");

        exec.shutdown();

    }

}

##3、循环栅栏 CyclicBarrier
CyclicBarrier是另外一种多线程并发控制的实用工具。和CountDownLatch非常类似，它可以实现线程间的计数等待，但它的功能比CountDownLatch更加复杂强大。它有循环的功能，也就是这个计数器可以反复使用。

public class Soldier implements Runnable {
    private String soldier;
    private final CyclicBarrier cyclic;

    Soldier(CyclicBarrier cyclic, String soldierName) {
        this.cyclic = cyclic;
        this.soldier = soldierName;
    }

    public void run() {

        try {
            cyclic.await();  // 等待前面的任务执行完成。 再一起执行后面的任务。
            doWork();
            cyclic.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {

        }

    }

    void doWork(){

        try{
            Thread.sleep(Math.abs(new Random().nextInt()%10000));
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(soldier+": 任务完成。");
    }


}


public class BarrierRun  implements Runnable {

    boolean flag;
    int N;

    public BarrierRun(boolean flag, int N){
        this.flag = flag;
        this.N=N;
    }

    public void run() {
       if(flag){
           System.out.println("司令：[士兵 "+N+"个， 任务完成！");
       }else{
           System.out.println("司令：[士兵 "+N+"个， 集合完毕！");
           flag = true;
       }

    }

}

public class CyclicBarrierDemo {


    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<11;++i){
            System.out.println("士兵 "+i+"报道！");
            allSoldier[i] = new Thread(new Soldier(cyclic,"士兵"+i));
            allSoldier[i].start();

        }

    }


}

##4、线程阻塞工具栏 LockSupport

LockSupport 是一个非常方便使用的线程阻塞工具，它可以在线程内任意位置让线程阻塞。和Thead。suspend 相比，他弥补了由于resume在前发生，导致线程无法继续执行的情况。和Object.wait 相比，他不需要先获得某个对象的锁，也不会抛出InterruptedException异常。

LockSupport使用类似信号量的机制。它为每个线程准备了一个许可，如果许可可用，那么park函数立即返回，并且消费这个许可，如果许可不可用，就会阻塞，而unpark 则使得一个许可变为可用（但是和信号量不同的是，许可不能累加，你不可能拥有超过一个许可，它永远只有一个。）

public class ChangeObjectThread extends Thread {
    public static Object u = new Object();

    public ChangeObjectThread(String name) {
        super.setName(name);
    }

    public void run() {
        synchronized (u) {
            System.out.println("in " + getName());
            LockSupport.park();
            LockSupport.park();
        }

    }


}


public class LockSupportDemo {


    static ChangeObjectThread t1 = new ChangeObjectThread("t1");
    static ChangeObjectThread t2 = new ChangeObjectThread("t2");

    public static void main(String[] args) throws InterruptedException {
             t1.start();
             LockSupport.unpark(t1);
             Thread.sleep(1000);
             LockSupport.unpark(t1);// 这两个许可如果放在一块，只会产生一个许可，因为线程中有两个park，所以会一直阻塞，因此需要使用sleep分开。

             t2.start();

             //LockSupport.park(t1);

             LockSupport.unpark(t2);
             Thread.sleep(1000);
             LockSupport.unpark(t2);
             t1.join();
             t2.join();

    }

}