[笔记][Java7并发编程实战手册]2.5使用Lock实现同步二

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

概要

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

修改锁的公平性ReentrantLock

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

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

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

公平锁 ：有多个线程并发访问公平锁的临界区，这些锁会等待上一个锁释放锁之后被公平策略选择一个线程获取锁（该策略就是在CLH选择一个等待时间最长的线程来访问临界区）

非公平锁：没有任何条件约束

公平和非公平策略只适用于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. 指定的最后期限到了

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