[笔记][Java7并发编程实战手册]系列目录

概要

接上一篇文章，练习修改锁的公平性，和在所中使用条件。

修改锁的公平性ReentrantLock

    /**
     *构造一个锁对象，默认为非公平锁
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

根据ReentrantLock的构造可以看出来，默认会构造非公平锁；

公平锁与非公平锁有什么区别

1. 公平锁 ：有多个线程并发访问公平锁的临界区，这些锁会等待上一个锁释放锁之后被公平策略选择一个线程获取锁（该策略就是在CLH选择一个等待时间最长的线程来访问临界区）
2. 非公平锁：没有任何条件约束
3. 公平和非公平策略只适用于lock() 和unlock()方法。而Lock接口的tryLock方法没有将线程置于休眠，fair属性并不影响这个方法。

详细解说请参考 Java多线程系列–“JUC锁”03之 公平锁(一)

示例演示公平策略

编写一个打印方法。里面有两个临界区，为了方便测试当前线程被执行后，第二个临界区等待锁的时间。才能看出效果

public class Client {
    public static void main(String[] args) throws InterruptedException {
        final FairSyncDemo fsd = new FairSyncDemo();
        Thread[]  arr = new Thread[10];
        for (int i = 0;i < 10 ;i++){
            arr[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    fsd.print();
                }
            });
        }
        for (int i = 0;i < arr.length ;i++){
            arr[i].start();
            Thread.sleep(100);  //让线程启动的时间增加。让公平锁来选择谁等待最久
        }

    }
}
class FairSyncDemo {
    private ReentrantLock lock = new ReentrantLock(true);  //构造公平锁
    public void print(){
        lock.lock();
        Long time = (long)(Math.random() * 1000);
        System.out.println(Thread.currentThread().getName() + ",打印耗时" + time  + "毫秒");
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.unlock();

        lock.lock();
        Long time2 = (long)(Math.random() * 1000);
        System.out.println(Thread.currentThread().getName() + ",stp2打印耗时" + time2  + "毫秒");
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.unlock();
    }
}

某一次的运行结果：

Thread-0,打印耗时821毫秒
Thread-1,打印耗时23毫秒
Thread-2,打印耗时19毫秒
Thread-3,打印耗时455毫秒
Thread-4,打印耗时951毫秒
Thread-5,打印耗时857毫秒
Thread-6,打印耗时680毫秒
Thread-7,打印耗时36毫秒
Thread-8,打印耗时116毫秒
Thread-0,stp2打印耗时107毫秒
Thread-1,stp2打印耗时960毫秒
Thread-2,stp2打印耗时598毫秒
Thread-9,打印耗时236毫秒
Thread-3,stp2打印耗时969毫秒
Thread-4,stp2打印耗时774毫秒
Thread-5,stp2打印耗时657毫秒
Thread-6,stp2打印耗时766毫秒
Thread-7,stp2打印耗时83毫秒
Thread-8,stp2打印耗时782毫秒
Thread-9,stp2打印耗时745毫秒

结果说明：
我们启动十个线程的时候，每启动一个线程，睡眠100毫秒，
从Thread-0,打印耗时821毫秒 到 Thread-0,stp2打印耗时107毫秒，这段时间中。stp2等待的时间为线程1-8所运行的时间，等待时间大概是3000多毫秒了。（这里的一个策略我不太清楚)所以就被公平策略给选中了继续执行临界区代码。

下面的结果是非公平锁的运行结果：
修改为非公平锁： private ReentrantLock lock = new ReentrantLock(false); //构造公平锁

Thread-0,打印耗时178毫秒
Thread-0,stp2打印耗时492毫秒
Thread-1,打印耗时534毫秒
Thread-1,stp2打印耗时951毫秒
Thread-2,打印耗时422毫秒
Thread-2,stp2打印耗时882毫秒
Thread-3,打印耗时353毫秒
Thread-3,stp2打印耗时487毫秒
Thread-4,打印耗时130毫秒
Thread-4,stp2打印耗时74毫秒
Thread-5,打印耗时900毫秒
Thread-5,stp2打印耗时90毫秒
Thread-6,打印耗时568毫秒
Thread-7,打印耗时676毫秒
Thread-7,stp2打印耗时220毫秒
Thread-8,打印耗时511毫秒
Thread-8,stp2打印耗时998毫秒
Thread-9,打印耗时171毫秒
Thread-9,stp2打印耗时425毫秒
Thread-6,stp2打印耗时88毫秒

结果说明：
　　很明显能看出来公平与飞公平的效果相差有多大。

在锁中使用多条件condition

在lock中提供了与之关联的条件，一个锁可能关联一个或则多个条件，这些条件通过condition接口声明。目的是运行线程获取锁并且查看等待某一个条件是否满足，如果不满足则挂起直到某个线程唤醒它们。condition接口提供了挂起线程和唤起线程的机制；

示例演示条件的使用

ok,介绍下下面一堆代码所做的事情：使用了5个线程设置(生产)一个数值，使用5个线程移除(消费)这个数值；
在add 和 remoe中使用Condition来代替监视器锁的wait操作。和唤醒操作。

值得注意的是：
1. ConDemo 这个内部类修改成Con 启动抛出找不到类的错误异常（不知道con是关键字还是什么原因）
2. 读写线程数量如果不对等，将会出现死锁。
3. 所有的条件Condition必须使用对等的锁对象来创建lock.newCondition();
4. 条件必须用在lock() 和 unlock() 方法之间。
5. 在判定条件是否满足，需要在循环中判定，未满足条件的不能离开循环体，否则数据将得不到我们想要的结果
6. 调用await()方法进入休眠的线程可能会被中断，所以必须处理InterruptedException 异常

public class Client {
    public static void main(String[] args) throws InterruptedException {
        final ConDemo con = new ConDemo();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    con.add();
                }
            }).start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    con.remove();
                }
            }).start();
        }
    }
}

class ConDemo {
    private ReentrantLock lock = new ReentrantLock(); //构造锁
    private Long depot = null;   //充当仓库，当有值的时候，会被remove走，并且设置为null。表示被取走了，等待add一个数
    private Condition removeCon;
    private Condition addCon;

    public ConDemo() {
        this.removeCon = lock.newCondition();
        this.addCon = lock.newCondition();
    }

    /**
     * 设置
     */
    public void add() {
        lock.lock();
        try {
            while (depot != null) {  //有值，则等待 被取走。后再设置值
                addCon.await();  //让当前线程操作等待
            }
            depot = (long) (Math.random() * 1000);
            System.out.println(Thread.currentThread().getName() + ",----设置了：" + depot);
            //唤醒条件，让等待取走值的线程操作
            removeCon.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 移除设置的数
     */
    public void remove() {
        lock.lock();
        try {
            while (depot == null) {  //没有值可取，则让条件等待
                removeCon.await();  //让移除操作等待
            }
            System.out.println(Thread.currentThread().getName() + ",拿走了：" + depot);
            depot = null;
            //唤醒条件，让等待设置值的线程。赶快设置值
            addCon.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

某一次的运行结果：

Thread-2,----设置了：274
Thread-8,拿走了：274
Thread-1,----设置了：358
Thread-5,拿走了：358
Thread-0,----设置了：407
Thread-7,拿走了：407
Thread-3,----设置了：761
Thread-9,拿走了：761
Thread-4,----设置了：250
Thread-6,拿走了：250

结果说明：可以看出以上的结果：有值了，才能被取走，被取走了，才能被生产一个值。

condition中的其他api

await(long time, TimeUnit unit)

boolean await(long time, TimeUnit unit) throws InterruptedException;

该方法直到以下情况之一之前，线程将一直处于休眠状态：
1. 其他某个线程中断当前线程
2. 其他某个线程调用了将当前线程挂起的条件的singal()或singalAll()方法
3. 指定的等待时间已经过去

awaitUninterruptibly()

它是不可中断的。这个线程将休眠直到其他某个线程调用了将他挂起的条件的singal()或则signalAll()方法。

awaitUntil(Date date)

直到发生以下情况之一之前，线程将一直处于休眠状态。
1. 其他某个线程中断当前线程
2. 其他某个线程调用了将他挂起的条件的dingal()或signalAll()方法
3. 指定的最后期限到了

也可以将条件与读写锁一起使用。