Java并发程序设计（四）JDK并发包之同步控制

JDK并发包之同步控制

一、重入锁

重入锁使用java.util.concurrent.locks.ReentrantLock来实现。示例代码如下：

public class TryReentrantLock implements Runnable{

    static ReentrantLock lock=new ReentrantLock();
    static int i=0;
    @Override
    public void run() {
        for(int j=0;j<10000;j++){
            lock.lock();
            try{
                i++;
            }finally {
                lock.unlock();
            }

            //重入锁可以反复进入，当然这种进入仅限于一个线程！因此可以如下：
            /*lock.lock();
            lock.lock();
            try{
                i++;
            }finally {
                lock.unlock();
                lock.unlock();
            }*/
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TryReentrantLock l=new TryReentrantLock();
        Thread t1=new Thread(l);
        Thread t2=new Thread(l);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(i);
    }
}

对于synchronized来说，如果一个线程在等待锁，那么结果只有两种情况，要么它获得这把锁继续执行，要么继续等待锁。而对于使用重入锁的线程来说则不同，线程在等待锁的过程中，程序可以根据需要取消对锁的请求。

public class IntLock implements Runnable{
    public static ReentrantLock lock1=new ReentrantLock();
    public static ReentrantLock lock2=new ReentrantLock();
    int state;

    /*控制加锁顺序，便于产生死锁。*/
    public IntLock(int state){
        this.state=state;
    }
    @Override
    public void run() {
        try{
            if(state==1){
                lock1.lockInterruptibly(); //设置可中断的锁
                try{
                    Thread.sleep(500); //便于产生死锁
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                lock2.lockInterruptibly();
            }else{
                lock2.lockInterruptibly();
                try{
                    Thread.sleep(500);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                lock1.lockInterruptibly();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(lock1.isHeldByCurrentThread()) lock1.unlock();
            if(lock2.isHeldByCurrentThread()) lock2.unlock();
            System.out.println(Thread.currentThread().getName()+" :quit!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        IntLock intLock1=new IntLock(1);
        IntLock intLock2=new IntLock(2);
        Thread t1=new Thread(intLock1);
        t1.setName("t1");
        Thread t2=new Thread(intLock2);
        t2.setName("t2");
        t1.start(); t2.start();
        Thread.sleep(1000);
        t2.interrupt();
    }
}

使用tryLock()进行限时等待。

public class TimeLock implements Runnable{
    public static ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        try{
            if(lock.tryLock(5, TimeUnit.SECONDS)){
                //注意返回布尔值.如果使用无参数的tryLock方法，
                // 当锁被占用时，线程会不等待，并返回false。
                Thread.sleep(6000);
            }else{
                System.out.println("Get lock failed!");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (lock.isHeldByCurrentThread()) lock.unlock();
        }
    }

    public static void main(String[] args){
        TimeLock timeLock=new TimeLock();
        Thread t1=new Thread(timeLock);
        Thread t2=new Thread(timeLock);
        t1.start();
        t2.start();

    }
}

公平锁：

大多数情况下，锁的申请都是不公平，随机的。而公平锁，讲究“先来后到”！因此公平锁的一大特点是不会产生饥饿。重入锁允许我们对其公平性进行设置：

public ReentrantLock(boolean fair); //true表示公平锁

公平锁缺点：性能相对低下。

二、重入锁的好基友Condition

Condition的做用类似于wait()和notify（）只不过Condition和ReentrantLock配合。

Condition接口的基本方法：

void await() throws InterruptedException //释放当前线程持有的锁，进入等待状态，当其他线程使用signal或signalAll()方法时继续执行。当线程被中断时会跳出等待。

void awaitUninterruptibly();与await()方法相似，当中断时不会跳出等待。

void signal();
void signalAll();

用法示例：

public class ReentrantCondition implements Runnable{
    static ReentrantLock lock=new ReentrantLock();
    static Condition condition=lock.newCondition();

    @Override
    public void run() {
        try{
            lock.lock();
            System.out.println(Thread.currentThread().getName()+" is running fast!");
            condition.await();
            System.out.println(Thread.currentThread().getName()+" is going no.");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantCondition rc=new ReentrantCondition();
        Thread t=new Thread(rc,"King of Lock");
        t.start();

        Thread.sleep(2000);
        lock.lock(); //调用signal前先要获得锁
        condition.signal();
        lock.unlock(); //调用singal后要释放锁，以让给被唤醒的线程。
    }
}

三、允许多个线程同时访问：信号量（Semaphore）

Semaphore可以指定多个线程同时访问一个资源。

public Semaphore(int permits); //permits指定同时能有几个线程访问同一资源。
public Semaphore(int permits,boolean fair) //fair指定是否采用公平锁

Semaphore主要的逻辑方法有：

public void acquire()  //尝试获得一个准入许可，若无法获得，则线程会等待，直到有线程释放了一个许可，或者当前线程被中断
public void acquireUninterruptibly() //不响应中断
public void release() //释放一个许可

四、ReadWriteLock读写锁

读写锁允许多个线程同时读。

五、CountDownLatch倒计时器

通常用来控制线程等待，可以让某个线程等待直到倒计时结束，再开始执行。

public CountDownLatch(int count) //count为需要完成几个线程上的任务，CountDownLatch上的线程才能继续执行。

示例代码：

public class CountDownLatchDemo implements Runnable{
    static final CountDownLatch latch=new CountDownLatch(10); //需要完成10个线程的任务，
    // CountDownLatch上的线程才能继续执行
    static final CountDownLatchDemo demo=new CountDownLatchDemo();

    @Override
    public void run() {
        try{
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+" :mission completed!");
            latch.countDown();//通知CountDownLatch一个任务已经完成。
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService ex= Executors.newFixedThreadPool(10);
        for(int i=0;i<10;i++){
            ex.submit(demo);
        }

        latch.await(); //设置要等待其他线程完成的那个线程
        System.out.println("Killed them all!");
        ex.shutdown();
    }
}

六、循环栅栏：CyclicBarrier

与CountDownLatch类似CyclicBarrier也是用来阻止线程继续执行，让线程进入等待状态。但此计数器可以反复使用。

public CyclicBarrier(int parties,Runnable barrierAction) //barrierAction为计数完成后要执行的动作

示例代码：

public class CyclicBarrierDemo {

    public static class Soldier implements Runnable{

        private String name;
        private final CyclicBarrier barrier;

        Soldier(String name,CyclicBarrier barrier){
            this.name=name;
            this.barrier=barrier;
        }

        @Override
        public void run() {
            try{
                barrier.await(); //进入等待状态，直到所有线程完成计数。
                doWork();        //所有线程完成一次await，继续执行。
                barrier.await(); //第二次await再次进入等待状态。
            }catch (Exception e){

            }
        }

        void doWork(){
            try{
                Thread.sleep(Math.abs(new Random().nextInt()%10000));
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("任务完成！");
        }
    }

    public static class FlyRun implements Runnable{
        boolean flag;
        int count;

        public FlyRun(boolean flag,int count){
            this.flag=flag;
            this.count=count;
        }

        @Override
        public void run() {
            if (flag) System.out.println("队长："+count+" 个士兵完成任务！");
            else {
                System.out.println("队长："+count+" 个士兵集合完毕！");
                flag=true;
            }
        }
    }

    public static void main(String[] args){
        final int count=12;
        Thread[] soldiers=new Thread[count];
        boolean flag=false;
        CyclicBarrier barrier=new CyclicBarrier(count,new FlyRun(flag,count));
        //集合队伍
        System.out.println("集合队伍！");
        for(int j=0;j<count;j++){
            System.out.println("士兵"+j+"报道！");
            soldiers[j]=new Thread(new Soldier("士兵"+j,barrier));
            soldiers[j].start();
        }
    }
}

七、线程阻塞工具类：LockSupport

LockSupport可以在线程内任意位置让线程阻塞。但与Object.wait()不同，它不需要先获得某个对象的锁，也不会抛出InterruptedException异常。示例代码：

public class LockSupportDemo {

    public static Object instance=new Object();
    public static ChangThread t1=new ChangThread("t1");
    public static ChangThread t2=new ChangThread("t2");

    public static class ChangThread extends Thread{
        public ChangThread(String name){
            super.setName(name);
        }

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

    }

    public static void main(String[] args) throws InterruptedException {
        t1.start();
        Thread.sleep(100);
        t2.start();
        LockSupport.unpark(t1); //即使unpark()发生在park前，程序也能正常执行。
        LockSupport.unpark(t2);
        t1.join();
        t2.join();
    }
}

park还支持中断影响，且不抛出异常。