Yvan's Blog

hibernate3.jar和hibernate-core.jar的区别

Fri, 07 Aug 2015 00:00:00 +0000

今天按照教程做一个SSH的例子，向项目中添加hibernate支持，教程中没有使用maven，遂自己上网到maven库中查询hibernate的jar包，教程中使用的是hibernate3.jar，maven库中并没有这个jar包，倒是hibernate-core之类的一大堆，这可糊涂了，这两个jar包有什么区别呢？

上网搜索一番也没找到具体的解释，打开hibernate3.jar，发现hibernate-distribution-3.6.0.Final.pom，噢，原来这个jar包应该叫hibernate-distribution啊，那么和core包又有啥区别呢？

在pom中发现如下内容：

    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-ehcache</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-jbosscache</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-infinispan</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-oscache</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-swarmcache</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-proxool</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>hibernate-envers</artifactId>
        <version>${project.version}</version>
    </dependency>

因此，初步推测，hibernate3.jar相当于hibernate-core.jar，hibernate-ehcache.jar等的组合。

Eclipse使用Maven创建Web时报错：Could not resolve archetype

Mon, 03 Aug 2015 00:00:00 +0000

问题描述：

　　使用Eclipse自带的Maven插件创建Web项目时报错：

	Could not resolve archetype org.apache.maven.archetypes:maven-archetype-webapp:RELEASE from any of the configured repositories.
	Could not resolve artifact org.apache.maven.archetypes:maven-archetype-webapp:pom:RELEASE
	Failed to resolve version for org.apache.maven.archetypes:maven-archetype-webapp:pom:RELEASE: Could not find metadata org.apache.maven.archetypes:maven-archetype-webapp/maven-metadata.xml in local (C:\Users\liujunguang\.m2\repository)
	Failed to resolve version for org.apache.maven.archetypes:maven-archetype-webapp:pom:RELEASE: Could not find metadata org.apache.maven.archetypes:maven-archetype-webapp/maven-metadata.xml in local (C:\Users\liujunguang\.m2\repository)

解决方法：

　　把.m2文件夹删除了，再新建就不报错了。（这方法有点暴力）

———————–2014-08-04 Update——————————– 　　

没想到原因是，上次把maven库地址配置成成oschina的，而oschina的库挂了，所以新建maven项目失败了，删除.m2中的配置文件后，maven就使用中央库，就没问题了。

Java编程思想 - 第二十一章、并发（八）

Fri, 24 Apr 2015 00:00:00 +0000

###21.9 性能调优

这个小节主要讲的是优化，但是高德纳不是说过嘛——Premature optimization is the root of all evil.所以等到真正发现有问题再仔细研究，现在看看估计就忘了。所以我先大概了解一下关于锁的问题，其他等遇到具体场景再说：）

####1. 免锁容器

####2. 乐观加锁

####3. ReadWriteLock

####4.

Java编程思想 - 第二十一章、并发（七）

Sun, 19 Apr 2015 00:00:00 +0000

###21.8 仿真

这个小节是综合运用前面7个小节的知识来完成一个小的需求。虽然很简单，但是也有地方值得自己学习，所以我直接上代码了。

####1. 银行出纳问题

模拟一个银行，有顾客会来银行办理业务，而处理业务的是出纳员，出纳员很多，又需要管理人员。所以抽象了三个 Entity，分别是顾客，出纳员，出纳员经理。抓住这三个核心 Entity 就可以理解其他了，嗯，代码我已经注释的非常清楚了。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
package concurrency.bidsimulation;

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

// 去银行办事的顾客
class Customer {
    // 该顾客办理业务需要的时间
    private final int serviceTime;

    public Customer(int serviceTime) {
        this.serviceTime = serviceTime;
    }

    public int getServiceTime() {
        return serviceTime;
    }

    @Override
    public String toString() {
        return "[" + serviceTime + "] ";
    }
}

// 每个柜台都会排队，这个就模拟用户排队
class CustomerLine extends ArrayBlockingQueue<Customer> {
    /**
     * 
     */
    private static final long serialVersionUID = 7788436315954397218L;

    public CustomerLine(int maxSize) {
        super(maxSize);
    }

    public String toString() {
        if (this.size() == 0) {
            return "[柜台目前无人办理业务，空闲中...]";
        }
        StringBuilder sb = new StringBuilder();
        for (Customer customer : this) {
            sb.append(customer);
        }
        return sb.toString();
    }
}

/**
 * 模拟来银行办理业务的顾客:<br>
 * 
 * 1. 它们来的时间完全随机<br>
 * 2. 顾客会随机选择要排队的柜台（一般都是选择人少的...)<br>
 * 3. 办理业务的时间也是随机
 * 
 */
class CustomerGenerator implements Runnable {
    private CustomerLine customerLine;
    private static Random random = new Random(47);

    public CustomerGenerator(CustomerLine customerLine) {
        this.customerLine = customerLine;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // 某位顾客来银行办理业务
                TimeUnit.MILLISECONDS.sleep(random.nextInt(300));
                // 在哪个柜台？用多少时间？
                customerLine.put(new Customer(random.nextInt(1000)));
            }
        } catch (InterruptedException e) {
            System.out.println("门坏了，，，，顾客没法来了= =" + e);
        }
        System.out.println("下班，顾客不能再来办理业务了。");
    }
}

/**
 * 出纳员
 * 
 */
class Teller implements Runnable, Comparable<Teller> {
    private static int counter = 0;
    // 出纳员编号通过 counter 来获得，所以 counter 是隐藏的
    private final int id = counter++;
    // 负责的顾客队伍（也就是服务的柜台）
    private CustomerLine customerLine;
    // 记录出纳员服务的顾客数，和后面经理分配活儿有关
    private int customerServed = 0;
    // 出纳员服务柜台的状态。如果出纳员有事，就设置为 false，代表当前柜台不能服务
    private boolean isServingCustomerLine = true;

    public Teller(CustomerLine customerLine) {
        this.customerLine = customerLine;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // 这个是阻塞的哦
                Customer customer = customerLine.take();
                TimeUnit.MILLISECONDS.sleep(customer.getServiceTime());
                // TODO 这个有疑问，为啥要加同步控制块，没有临界资源啊
                synchronized (this) {
                    customerServed++;
                    while (isServingCustomerLine == false) {
                        wait();
                    }

                }
            }
        } catch (InterruptedException e) {
            System.out.println(this + "被打断，有其他事情需要处理...");
        }
        System.out.println("出纳员下班了...");
    }

    // 出纳员有事情，自己或者有其他紧急任务
    public synchronized void doSomethingElse() {
        customerServed = 0;
        isServingCustomerLine = false;
    }

    // 出纳员处理任务完毕，回到工作岗位
    public synchronized void comebackWorking() {
        if (isServingCustomerLine == false) {
            System.out.println(this + "负责的柜台继续提供服务...");
            isServingCustomerLine = true;
            notifyAll(); // 和 wait()遥相呼应
        }
    }

    @Override
    public String toString() {
        return "出纳员" + id + " ";
    }

    // 经理需要用优先队列安排工作，所以服务人数少的人优先干活（以服务人数不按工作量，呵呵呵）
    public synchronized int compareTo(Teller teller) {
        return this.customerServed - teller.customerServed;
    }
}

// 虽然实现了 Runnable，但是其实只有一个经理。实现是为了让 ExecutorService 统一管理
class TellerManager implements Runnable {

    // 管理所有的出纳员
    private ExecutorService exec;
    // 同时管理所有的柜台
    private CustomerLine customerLine;
    // 按照服务顾客数目排序，少的分配活儿
    private PriorityQueue<Teller> workingTellers = new PriorityQueue<Teller>();
    // 分配去干其他事情的出纳员
    private Queue<Teller> tellersDoingOtherThings = new LinkedList<Teller>();
    // 调整算法因子
    private int adjustmentPeriod;

    public TellerManager(ExecutorService exec, CustomerLine customerLine, int adjustmentPeriod) {
        this.exec = exec;
        this.customerLine = customerLine;
        this.adjustmentPeriod = adjustmentPeriod;

        // 经理下面最起码带个人不是。。。
        Teller teller = new Teller(customerLine);
        exec.execute(teller);
        workingTellers.add(teller);
    }

    // 经理会根据自己的经验安排工作
    public void adjustTellerNumber() {
        // 如果队伍很长（顾客数目是出纳员数目的2倍多）
        if (customerLine.size() / workingTellers.size() > 2) {
            // 如果有在做其他事情的出纳员，要事优先原则
            if (tellersDoingOtherThings.size() > 0) {
                Teller teller = tellersDoingOtherThings.remove();
                teller.comebackWorking();
                workingTellers.add(teller);
                return;
            }
            // 人确实不够了，通知 hr 赶紧去招人...
            Teller teller = new Teller(customerLine);
            exec.execute(teller);
            workingTellers.add(teller);
            return;
        }

        // 队伍很短,不能让出纳员闲着...（老板都是这想法吧= =）
        if (workingTellers.size() > 1 && customerLine.size() / workingTellers.size() < 2) {
            reassignOneTeller();
        }
        // 队伍压根没人,留一个出纳员工作即可,其他都去干别的活儿，不能让出纳员闲着...
        if (customerLine.size() == 0) {
            while (workingTellers.size() > 1) {
                reassignOneTeller();
            }
        }
    }

    // 分配出纳员去干别的活儿
    private void reassignOneTeller() {
        Teller teller = workingTellers.poll();
        // poll() 在队列为空的时候返回 null，不用判断 teller为 null 是因为上面肯定留了一个出纳员在 woerkingTellers
        teller.doSomethingElse();
        tellersDoingOtherThings.offer(teller);
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                TimeUnit.MILLISECONDS.sleep(adjustmentPeriod);
                adjustTellerNumber();
                System.out.print("{排队中的顾客：" + customerLine + "}----");
                System.out.print("{目前工作中的出纳员：[");
                for (Teller teller : workingTellers) {
                    System.out.print(teller);
                }
                System.out.println("]}");
            }
        } catch (InterruptedException e) {
            System.out.println("经理工作被打断");
        }
        System.out.println("经理下班了...");
    }

    @Override
    public String toString() {
        return "我是所有出纳员的经理...";
    }
}

public class BankTellerSimulation {
    static final int MAX_SIZE = 50;
    static final int ADJUSTMENT_PERIOD = 1000;

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        CustomerLine customerLine = new CustomerLine(MAX_SIZE);
        exec.execute(new CustomerGenerator(customerLine));
        exec.execute(new TellerManager(exec, customerLine, ADJUSTMENT_PERIOD));
        // 结束模拟：带结束时间或者按下 Enter
        if (args.length > 0) {
            TimeUnit.SECONDS.sleep(new Integer(args[0]));
        } else {
            System.out.println("Press 'Enter' to quit.");
            System.in.read();
        }
        exec.shutdownNow();
    }
}

####2. 饭店仿真

这个例子感觉不咋地，就跳过去了= =

####3. 分发问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
package concurrency;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * 第一步：Chassis 创建一个 new MyCar，然后装底盘<br>
 * 第二步：Assembler 装配，从 RobotPool 中取得机器人资源，组装引擎、动力系统、轮胎<br>
 * 第三步：组装完成后会有一个记录系统，并将完成的车辆放入 finishingQueue<br>
 */
class MyCar {
    private final int id;
    private boolean engine;
    private boolean driveTrain;
    private boolean wheels;

    public MyCar(int id) {
        this.id = id;
    }

    public MyCar() {
        id = -1;
    }

    public synchronized int getId() {
        return id;
    }

    public synchronized void addEngine() {
        engine = true;
    }

    public synchronized void addDriveTrain() {
        driveTrain = true;
    }

    public synchronized void addWheels() {
        wheels = true;
    }

    public synchronized String toString() {
        return "Car " + id + " [" + " engine: " + engine + " driveTrain: " + driveTrain + " wheels: " + wheels + " ]";
    }
}

// 模拟工厂的流水线
class CarQueue extends LinkedBlockingQueue<MyCar> {
    private static final long serialVersionUID = -8022590210916666885L;
}

// 底盘环节
class ChassisBuilder implements Runnable {
    // 底盘的 carQueue 是一辆车的第一个入口
    private CarQueue carQueue;
    private int counter = 0;

    public ChassisBuilder(CarQueue carQueue) {
        this.carQueue = carQueue;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // 创建新车 & 安装底盘
                MyCar myCar = new MyCar(counter++);
                TimeUnit.MILLISECONDS.sleep(500);
                System.out.println(myCar + "底盘已经搞定，其余部件开始装配：");
                carQueue.put(myCar);
            }
        } catch (InterruptedException e) {
            System.out.println("底盘制造被终止！");
        }
        System.out.println("底盘装配线关闭...");
    }
}

// 组装引擎、动力系统、轮胎环节
class Assembler implements Runnable {
    // 底盘之后的第二道工序
    private CarQueue chassisQueue;
    private CarQueue finishingQueue;
    private MyCar myCar;
    // 不用 CountDownLatch 是因为要复用
    private CyclicBarrier cyclicBarrier = new CyclicBarrier(4);
    private RobotPool robotPool;

    public Assembler(CarQueue chassisQueue, CarQueue finishingQueue, RobotPool robotPool) {
        this.chassisQueue = chassisQueue;
        this.finishingQueue = finishingQueue;
        this.robotPool = robotPool;
    }

    public MyCar car() {
        return myCar;
    }

    public CyclicBarrier barrier() {
        return cyclicBarrier;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // 阻塞直到底盘装配线传来待组装的车
                myCar = chassisQueue.take();

                // 使用机器人装配
                robotPool.consume(EngineRobot.class, this);
                robotPool.consume(DriveTrainRobot.class, this);
                robotPool.consume(WheelRobot.class, this);

                // 第四个 barrier，表示车组装完成
                cyclicBarrier.await();
                finishingQueue.put(myCar);
            }
        } catch (InterruptedException e) {
            System.out.println("装配引擎、动力系统、轮胎被终止！");
        } catch (BrokenBarrierException e) {
            throw new RuntimeException(e);
        }

        System.out.println("组装装配线关闭...");
    }
}

// 通报系统
class Reporter implements Runnable {
    private CarQueue finishingQueue;

    public Reporter(CarQueue finishingQueue) {
        this.finishingQueue = finishingQueue;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                System.out.println(finishingQueue.take());
            }
        } catch (InterruptedException e) {
            System.out.println("通报系统被终止！");
        }
        System.out.println("通报系统关闭...");
    }
}

// 抽象组装过程中的三个机器人
abstract class Robot implements Runnable {
    private RobotPool robotPool;
    protected Assembler assembler;
    private boolean isWorking = false;

    public Robot(RobotPool robotPool) {
        this.robotPool = robotPool;
    }

    public Robot assignAssembler(Assembler assembler) {
        this.assembler = assembler;
        return this;
    }

    // 开始干活
    public synchronized void engage() {
        isWorking = true;
        notifyAll();
    }

    abstract protected void performService();

    @Override
    public void run() {
        try {
            // wait until needed
            powerDown();
            while (!Thread.interrupted()) {
                performService();
                assembler.barrier().await();
                // 已经做完了
                powerDown();
            }
        } catch (InterruptedException e) {
            System.out.println("机器人自动装配被终止！");
        } catch (BrokenBarrierException e) {
            throw new RuntimeException(e);
        }
        System.out.println(this + "关闭...");
    }

    // 消除状态，停止工作。直到有可用的机器人
    private synchronized void powerDown() throws InterruptedException {
        isWorking = false;
        assembler = null;
        robotPool.releaser(this);
        while (isWorking == false) {
            wait();
        }
    }

    @Override
    public String toString() {
        return getClass().getName();
    }
}

// 安装引擎机器人
class EngineRobot extends Robot {
    public EngineRobot(RobotPool robotPool) {
        super(robotPool);
    }

    @Override
    protected void performService() {
        System.out.println(this + " 安装引擎...");
        assembler.car().addEngine();
    }
}

// 安装动力系统机器人
class DriveTrainRobot extends Robot {
    public DriveTrainRobot(RobotPool robotPool) {
        super(robotPool);
    }

    @Override
    protected void performService() {
        System.out.println(this + " 安装动力系统...");
        assembler.car().addDriveTrain();
    }
}

// 安装轮胎机器人
class WheelRobot extends Robot {
    public WheelRobot(RobotPool robotPool) {
        super(robotPool);
    }

    @Override
    protected void performService() {
        System.out.println(this + " 安装轮胎...");
        assembler.car().addWheels();
    }
}

// 机器人池
class RobotPool {
    private Set<Robot> pool = new HashSet<Robot>();

    // 使用完毕的机器人重新放入资源池，然后通知等待该机器人的任务
    public synchronized void produce(Robot robot) {
        pool.add(robot);
        notifyAll();
    }

    // 机器人消费者
    public synchronized void consume(Class<? extends Robot> robotType, Assembler assembler) throws InterruptedException {
        for (Robot robot : pool) {
            if (robot.getClass().equals(robotType)) {
                pool.remove(robot);
                robot.assignAssembler(assembler);
                robot.engage();
                return;
            }
        }
        wait();
        consume(robotType, assembler);
    }

    // 释放资源，本质就是重新加入到机器人池
    public synchronized void releaser(Robot robot) {
        produce(robot);
    }
}

public class CarBuilder {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();

        // 初始化机器人池，每个类型只有一个机器人，所以是临界资源
        RobotPool robotPool = new RobotPool();
        exec.execute(new EngineRobot(robotPool));
        exec.execute(new DriveTrainRobot(robotPool));
        exec.execute(new WheelRobot(robotPool));

        /**
         * 生产线正式启动。<br>
         * 故意把底盘装配（第一个环节）放在最后一个启动，反正 Assembler 会自动阻塞
         */
        CarQueue chassisQueue = new CarQueue();
        CarQueue finishingQueue = new CarQueue();
        exec.execute(new Assembler(chassisQueue, finishingQueue, robotPool));
        exec.execute(new Reporter(finishingQueue));
        exec.execute(new ChassisBuilder(chassisQueue));

        // 模拟程序在7秒后自动结束
        TimeUnit.SECONDS.sleep(7);
        exec.shutdownNow();
    }
}

PriorityQueue 源码剖析

Fri, 17 Apr 2015 00:00:00 +0000

###一、前言

昨天看《Java 编程思想》21.7小节的 DelayQueue 的时候，写了一个小例子。但是程序的输出和我的预期输出不符，debug 了一下是 add 出了问题，但是因为已经23：30了就直接睡了，今天把这个坑填了。

从文档我们知道，DelayQueue 是一个使用 PriorityQueue 的 BlockingQueue，其中优先级是由 Delayed 接口的 getDelay()方法返回的延迟到期时间决定的。问题就出在 DelayQueue.add()方法中。其实跟一下代码很好理解，我只是备忘一下。。。。。

###二、问题引入

首先描述一下我写的程序的需求：

现在正在进行一场考试，有2个规则：1. 开始考试30分钟后才能交卷子；2. 考试时间为120分钟。

需求超级简单吧？但是实现起来还是有点难度。说一下我的思路：

首先要有老师和学生
如何确定考试结束的状态？肯定是所有学生都交卷了才算考试结束，所以学生肯定都要起单独的线程，正好 CountDownLatch 满足需求（CyclicBarrier 多了个复用）
如果有学生不能在120分钟完成考试，应该强制收卷。这块比较难搞，怎么设计更合理？我想了2种方法：
1. 抽出老师、学生的共性：参加考试接口，这个参加考试接口实现 Delayed 接口，然后 DelayQueue 加入老师和所有学生，老师作为120分钟的哨兵。等 queue 的头是老师，后面的学生直接交卷子
2. 找一个其他班的不考试的学生作为助手，在120分钟时把未完成考试的学生卷子强行收上来
上面两种设计都有缺点：
1. 老师和学生虽然都参加考试，但是他们最好是不耦合的，老师只负责维护纪律，学生负责答题
2. 虽然解耦了，但是引入了第三方，没有形成一个闭环（如果第三方服务挂了怎么办？）

嗯，Done is better than perfect.先把这个需求实现了，再慢慢改进。实际上我的代码是第二种思路实现的，贴一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
package concurrency;

import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

class Teacher implements Runnable {

    private DelayQueue<Student> students = null;

    public Teacher(DelayQueue<Student> students) {
        this.students = students;
    }

    @Override
    public void run() {
        try {
            // 老师只负责看场子，考试结束后也是 Assistant 继续做事
            while (!Thread.interrupted()) {
                students.take().run();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class Student implements Runnable, Delayed {

    private String name;
    private int workTime;
    private int submitTime;
    private boolean timeOut = false;
    private CountDownLatch countDownLatch;

    public Student(String name, int workTime, CountDownLatch countDownLatch) {
        this.name = name;
        this.workTime = workTime;
        this.submitTime = (int) TimeUnit.NANOSECONDS.convert(System.nanoTime() + workTime, TimeUnit.NANOSECONDS);
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        if (timeOut == false) {
            System.out.println(name + " 完成考试...期望用时：" + workTime + ", 实际用时：" + workTime);
        } else {
            System.out.println(name + " 未完成考试...期望用时：" + workTime + ", 实际用时：120");
        }
        countDownLatch.countDown();
    }

    @Override
    public int compareTo(Delayed o) {
        Student that = (Student) o;
        return this.workTime - that.workTime;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(submitTime - System.nanoTime(), TimeUnit.NANOSECONDS);
    }

    public void setTimeOut(boolean timeOut) {
        this.timeOut = timeOut;
    }

    @Override
    public String toString() {
        return name + " 期望用时： " + workTime + "\n";
    }
}

// 助手，其实是考试结束的哨兵
class Assistant extends Student {

    private CountDownLatch countDownLatch = null;
    private Thread teacherThread = null;
    private DelayQueue<Student> students = null;

    public Assistant(String name, int workTime, CountDownLatch countDownLatch, Thread teacherThread,
            DelayQueue<Student> students) {
        super(name, workTime, countDownLatch);
        this.countDownLatch = countDownLatch;
        this.teacherThread = teacherThread;
        this.students = students;
    }

    @Override
    public void run() {
        System.out.println("\n考试时间到！！！！请大家放下纸笔，立即交卷！！！这不是在演习，这不是在演习！！！\n");
        // 告诉老师，时间到了，是我的 show time
        teacherThread.interrupt();
        /**
         * 将120分钟还没有完成的同学的试卷强制收上来.<br>
         * 
         * 问：但是这里为什么用的是 students.iterator()？这样不是重头遍历了吗？<br>
         * 答：DelayQueue<Student>前面的元素已经获取并且删除了，去看文档： <br>
         * 1. peek()不会删除头元素，如果队为空，返回 nulll<br>
         * 2. poll()会删除头元素，但是如果获取不到到期的元素，就会立马返回一个 null<br>
         * 3. take()会删除头元素，如果获取不到到期的元素，就会阻塞<br>
         */
        Student tempStudent = null;
        for (Iterator<Student> iterator = students.iterator(); iterator.hasNext();) {
            tempStudent = iterator.next();
            tempStudent.setTimeOut(true);
            tempStudent.run();
        }

        // 表示收卷子完成
        countDownLatch.countDown();

    }
}

public class MyExam {
    private static final int MIN_EXAM_TIME = 30;
    private static final int STUDENT_NUM = 20;
    private static Random random = new Random(47);

    public static void main(String[] args) throws InterruptedException {
        DelayQueue<Student> students = new DelayQueue<Student>();
        CountDownLatch countDownLatch = new CountDownLatch(STUDENT_NUM + 1);
        for (int i = 0; i < STUDENT_NUM; i++) {
            students.add(new Student("student " + (i + 1), MIN_EXAM_TIME + random.nextInt(120), countDownLatch));
        }

        // DEBUG
        // System.out.println(Arrays.asList(students));

        // 老师线程作用就是收取学生的试卷，本来需要同步锁机制。但是因为 DelayQueue 是一个使用
        // PriorityQueue 实现的 BlockingQueue，且使用 Delayed 接口的 getDelay()的时间作为比较的优先级
        // 所以，BlockingQueue 就隐藏了锁操作。
        Thread teacherThread = new Thread(new Teacher(students));

        students.add(new Assistant("强制收卷子...", 120, countDownLatch, teacherThread, students));

        teacherThread.start();
        countDownLatch.await();
        // 卷子全部收齐，考试结束
        System.out.println("考试结束！！！！！");
    }
}/*output:
student 5 完成考试...期望用时：31, 实际用时：31
student 10 完成考试...期望用时：37, 实际用时：37
student 3 完成考试...期望用时：43, 实际用时：43
student 7 完成考试...期望用时：58, 实际用时：58
student 6 完成考试...期望用时：59, 实际用时：59
student 2 完成考试...期望用时：65, 实际用时：65
student 9 完成考试...期望用时：72, 实际用时：72
student 11 完成考试...期望用时：78, 实际用时：78
student 12 完成考试...期望用时：78, 实际用时：78
student 20 完成考试...期望用时：88, 实际用时：88
student 18 完成考试...期望用时：91, 实际用时：91
student 8 完成考试...期望用时：110, 实际用时：110
student 19 完成考试...期望用时：110, 实际用时：110
student 15 完成考试...期望用时：119, 实际用时：119

考试时间到！！！！请大家放下纸笔，立即交卷！！！这不是在演习，这不是在演习！！！

student 1 未完成考试...期望用时：128, 实际用时：120
student 4 未完成考试...期望用时：131, 实际用时：120
student 14 未完成考试...期望用时：139, 实际用时：120
student 17 未完成考试...期望用时：148, 实际用时：120
student 13 未完成考试...期望用时：141, 实际用时：120
student 16 未完成考试...期望用时：148, 实际用时：120
考试结束！！！！！
*/

上面的程序能完成我的需求，但是考试结束后的学生竟然不是按照期望用时排序的，让我很诧异。因为加入队列的 compareTo() 我已经重写了啊，是按照期望用时(workTime)从小到大排序的，怎么输出就不对了呢？那个141是什么鬼！！！！刚开始以为是 compareTo 有 bug？但是compareTo()已经写过 N 次，就是简单的 ASCII 码比较，没出 bug 的可能啊，然后怀疑是程序逻辑有问题，就打印了 DelayQueue，结果果然不是按照期望用时排序的，于是 debug 了一下 add() 方法才算恍然大悟。。。。额，也就是本文的目的了：PriorityQueue 源码剖析。 ###三、PriorityQueue 源码剖析

先上干货：

PriorityQueue 文档上来就说了使用堆实现！！！！！没错，所以数组其实不是排序结果，而是维护了一个小顶堆。OK，核心已经说明。

如果数据结构没白学，这个类的核心已经算掌握80%了，剩下的就是一些小细节了。额，我就简单八一八。。

####0. 类属性 & 类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//默认初始化大小，11是什么鬼！！！
private static final int DEFAULT_INITIAL_CAPACITY = 11;  
//堆  
private transient Object[] queue;  
//当前大小  
private int size = 0;  
//比较器  
private final Comparator<? super E> comparator;  
//修改次数（增、删、改、查）  
private transient int modCount = 0;  

//增加  
public boolean add(E e)   
//出队（不删除）  
public E peek()  
//出队（删除）  
public E poll()  
//删除  
public boolean remove(Object o)  
//是否包含某元素  
public boolean contains(Object o)  
//清空  
public void clear()  
//扩容  
private void grow(int minCapacity)  
//查找  
private int indexOf(Object o)

####1. add()方法

堆在增加元素后，需要进行调整才能维护其最大堆或者最小堆的性质，下面以最小堆为例：

增加元素26，默认是从队尾增加，即直接添加到数组最后。下一步需要执行上滤。从上图可以看出，26比其父节点39小，因此两者交换位置；再次比较此时的26和其父节点30，30>26,调整位置，依次进行直到找到比26小的父节点，结束。

贴下源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//可以看出，add方法实际上是全部委托给offer(E)
public boolean add(E e) {  
        return offer(e);  
    }

public boolean offer(E e) { 
	// 第1步：判空 
    if (e == null)  
        throw new NullPointerException();  
    // 第2步:改变大小和扩容
    modCount++;  
    int i = size;  
    //检查容量（扩容）  
    if (i >= queue.length)  
        grow(i + 1);  
    //改变size  
    size = i + 1;  
    // 第3步：添加元素并上滤
    if (i == 0)  
        queue[0] = e;//无父节点 ，直接赋值  
    else  
        siftUp(i, e);//有父节点，需要上滤  
    return true;  
}

从上面的3步中可以看出，实际上关键的步骤是：grow() 和 siftUp()，下面贴下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/**
* 1：扩容方式是：当前队列大小queue.length<64，则增加一倍容量；反之则增加一半容量。
* 2：调用Arrays的copyOf函数 ，实际上调用了该函数
*/
private void grow(int minCapacity) {  
    if (minCapacity < 0) // overflow  
        throw new OutOfMemoryError();  
    int oldCapacity = queue.length;  
    // Double size if small; else grow by 50%  
    int newCapacity = ((oldCapacity < 64) ? ((oldCapacity + 1) * 2)  
            : ((oldCapacity / 2) * 3));  
    if (newCapacity < 0) // overflow  
        newCapacity = Integer.MAX_VALUE;  
    if (newCapacity < minCapacity)  
        newCapacity = minCapacity;  
    queue = Arrays.copyOf(queue, newCapacity);  
}  

// siftUp()：

//根据不同的比较方式，采取不同比较策略。下面以使用默认comparable的方式分析
private void siftUp(int k, E x) {  
    if (comparator != null)  
        siftUpUsingComparator(k, x);  
    else  
        siftUpComparable(k, x);  
}  

// 经典的堆 shiftUp 操作
private void siftUpComparable(int k, E x) {  
    Comparable<? super E> key = (Comparable<? super E>) x;  
    // 迭代到堆顶  
    while (k > 0) {  
        // 父节点
        int parent = (k - 1) >>> 1;  
        Object e = queue[parent];  
        // 满足小顶堆属性，退出  
        if (key.compareTo((E) e) >= 0)  
            break;  
        // 父节点元素下移  
        queue[k] = e;  
        // 新迭代 
        k = parent;  
    }  
    // 交换  
    queue[k] = key;  
}

####2. peek() 出队（不删除元素)

1
2
3
4
5
6
// 这个很简单，只是取出了其中的首位元素，但是并没有删除，不需要调整堆。
public E peek() {  
    if (size == 0)  
        return null;  
    return (E) queue[0];  
}

####3. poll() 出队（删除最小元素）

出队过程:

当最小元素14出队，从数组尾处取39赋值给队首。之后，进行和增加元素后相反的动作即下滤。首先选出根节点（父节点）39的两个孩子结点中较小者，和39交换位置；当39找到新位置后，执行同种方法，如果孩子结点为null或者都比39大，则结束。

贴下源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public E poll() {  
    // 优先队列为空，返回null  
    if (size == 0)  
        return null;  
    int s = --size;  
    modCount++;  
    // 取出队首  
    E result = (E) queue[0];  
    E x = (E) queue[s];  
    // 队尾赋值为null  
    queue[s] = null;  
    // 判断是否执行下滤  
    if (s != 0)  
        siftDown(0, x); //核心方法，这里把最后一个元素传进去了，而且添加位置是0
    return result;  
}

private void siftDown(int k, E x) {  
    if (comparator != null)  
    siftDownUsingComparator(k, x);  
    else  
    siftDownComparable(k, x);  
}  

/**
* k = 0，所以相当于堆顶空降一个元素，然后执行经典的 ShiftDown
*/
private void siftDownComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>)x;
        int half = size >>> 1;        // loop while a non-leaf
        while (k < half) {
            int child = (k << 1) + 1; // assume left child is least
            Object c = queue[child];
            int right = child + 1;
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                c = queue[child = right];
            if (key.compareTo((E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = key;
    }

####4. removeAt() 删除(这个有点意思，是删除堆中的某一个节点)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private E removeAt(int i) {  
    assert i >= 0 && i < size;  
    modCount++;  
    int s = --size;  
    // 如果删除的是最后一个元素，则将最后一个元素设为null
    if (s == i)  
        queue[i] = null;  
    else {  
        // 如果删除的不是最后一个元素，取出最后一个元素，并将最后一个元素设为null。执行 ShiftUp
        E moved = (E) queue[s];  
        queue[s] = null;  
        // 执行 ShiftDown 
        siftDown(i, moved);  
        // 如果下滤后元素位置没变，说明moved是该子树最小元素；之后需要执行上滤  
        // ShiftUp 和 ShiftDown 实际只会执行其中一个  
        if (queue[i] == moved) {  
            siftUp(i, moved);  
            if (queue[i] != moved)// iterator中会用到此处  
                return moved;  
        }  
    }  
    return null;  
}

####5. clear() 清除

1
2
3
4
5
6
7
// 这个很简单，只是遍历数组，删除（设为null）
public void clear() {  
    modCount++;  
    for (int i = 0; i < size; i++)  
        queue[i] = null;  
    size = 0;  
}

####6. contains() 是否包含

1
2
3
4
// 这个过程实际上就是查找过程
public boolean contains(Object o) {  
	return indexOf(o) != -1;  
}

####7. idnexOf() 查找

1
2
3
4
5
6
7
8
9
10
private int indexOf(Object o) {  
(o != null) {  
        //遍历数组查询  
        for (int i = 0; i < size; i++)  
            //如果是自定义的元素，重写equals方法是很有必要的  
            if (o.equals(queue[i]))  
                return i;  
    }  
    return -1;  
}

Java编程思想 - 第二十一章、并发（六）

Sun, 15 Mar 2015 00:00:00 +0000

###21.7 新类库中的构件

Java SE5的 java.util.concurrent 包中引入了大量设计用来解决并发问题的新类。学习这些“工具类”就可以专注于自己想要实现的功能而不是线程的同步、死锁等一堆令人头疼的细节。这一小节内容非常多，建议的学习方法是：

首先看目录，了解这一小节主要讲的是哪几种构件
通过构件的名字猜猜它们想实现的功能，然后通过查询文档总结一下每个构件的特点，适用的场景
尝试着去寻找项目中涉及到的点，然后具体学习这个构件的知识，之后用新构件重新实现这一块作为巩固

嗯，上面总结了一下学习这个小节的步骤（其实是因为太多了。。。。。我不想全看 T_T），那么我们就把目录摘出来看看吧。

###一、前言

下面是21.7小节的目录。嗯，发现一共是7个构件，现在从文档出发，逐个浏览一下（Mac 下有 Dash 这样的神器真是幸福啊，hiahiahiahia~）

21.7 新类库中的构件
- 21.7.1 CountDownLatch
- 21.7.2 CyclicBarrier
- 21.7.3 DelayQueue
- 21.7.4 PriorityBlockingQueue
- 21.7.5 使用 ScheduledExecutor 的温室控制器
- 21.7.6 Semaphore
- 21.7.7 Exchanger

下面我们先简单的“望文生义”一下，然后再逐个击破：）

CountDownLatch：名字直译为——倒计时锁。官方文档的描述是 A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.[一个线程同步辅助工具，可以让一个或多个线程等待直到其它线程的任务全部完成才会被唤醒。]
CyclicBarrier：和上面那个功能相似，只是上面的倒计时数值不能被重置，只能递减到0停止；而 CyclicBarrier 可以在倒计时数减为0之后重用（还是原来的值）
DelayQueue：无界的 BlockingQueue（前面生产者-消费者讲过哦），用于放置实现了 Delayed interface 的对象，其中的对象只能在到期时才能在队列中取走。这种队列是有序的，即队头对象的延期到期的时间最长。
PriorityBlockingQueue：优先队列的 BlockingQueue，具有可阻塞的读取操作。其实就是 BlockingQueue 的优先队列实现
使用 ScheduledExecutor 的温室控制器：
Semaphore：正常的锁（concurrent.Lock 或者 synchronized）在任何时刻都只能允许一个任务访问资源，而 Semaphore （计数信号量）允许 N 个任务同时访问这个资源。（是不是有池子的感觉嘞？？）
Exchanger：两个任务之间交换对象的栅栏。意思是各自拥有对象，离开栅栏时，就拥有对方持有的对象了。典型就是一个任务生产对象，一个任务消费对象。（值得思考，为啥要交换？我直接用一个容器或者 BlockingQueue 完全可以解耦啊，这个到底用在哪里？）

###二、代码来了

下面给每个构件都写个小例子，然后总结一下它们产生的原因和最佳使用场景。go go go!!

####1. CountDownLatch

文档也太详细了吧：

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

A CountDownLatch is initialized with a given count. The await methods block until the current count reaches zero due to invocations of the countDown() method, after which all waiting threads are released and any subsequent invocations of await return immediately. This is a one-shot phenomenon – the count cannot be reset. If you need a version that resets the count, consider using a CyclicBarrier【和 CyclicBarrier 的区别】.

A CountDownLatch is a versatile(多功能的) synchronization tool and can be used for a number of purposes. A CountDownLatch initialized with a count of one serves as a simple on/off latch, or gate: all threads invoking await wait at the gate until it is opened by a thread invoking countDown(). A CountDownLatch initialized to N can be used to make one thread wait until N threads have completed some action, or some action has been completed N times.【这里是使用场景：count=1为开关；count=N 重复 N 次】

A useful property of a CountDownLatch is that it doesn’t require that threads calling countDown wait for the count to reach zero before proceeding, it simply prevents any thread from proceeding past an await until all threads could pass.

同时文档提供了演示代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
Here is a pair of classes in which a group of worker threads use two countdown latches:

1. The first is a start signal that prevents any worker from proceeding until the driver is ready for them to proceed;
2. The second is a completion signal that allows the driver to wait until all workers have completed.
 
class Driver { // ...
   void main() throws InterruptedException {
     CountDownLatch startSignal = new CountDownLatch(1);
     CountDownLatch doneSignal = new CountDownLatch(N);

     for (int i = 0; i < N; ++i) // create and start threads
       new Thread(new Worker(startSignal, doneSignal)).start();

     doSomethingElse();            // don't let run yet
     startSignal.countDown();      // let all threads proceed
     doSomethingElse();
     doneSignal.await();           // wait for all to finish
   }
 }

 class Worker implements Runnable {
   private final CountDownLatch startSignal;
   private final CountDownLatch doneSignal;
   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
      this.startSignal = startSignal;
      this.doneSignal = doneSignal;
   }
   public void run() {
      try {
        startSignal.await();
        doWork();
        doneSignal.countDown();
      } catch (InterruptedException ex) {} // return;
   }

   void doWork() { ... }
 }

文档已经够清晰了，这里就不多废话了。

####2. CyclicBarrier

直译为循环栅栏，通过它可以让一组线程全部到达某个状态后再同时执行，也就是说假如有5个线程协作完成一个任务，那么只有当每个线程都完成了各自的任务（都到达终点），才能继续运行（开始领奖）。循环的意思是当所有等待线程都被释放（也就是所有线程完成各自的任务，整个程序开始继续执行）以后，CyclicBarrier 可以被重用。而上面的 CountDownLatch 只能用一次。

这个的文档也非常详细：

A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point[各个线程互相等待，CountDownLatch 是一个等待其他多个线程]. CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other[使用场景：固定数目的线程互相等待]. The barrier is called cyclic because it can be re-used after the waiting threads are released[为什么叫做循环是因为释放后可以重用].

A CyclicBarrier supports an optional Runnable command that is run once per barrier point, after the last thread in the party arrives, but before any threads are released[一个可选的参数是 Runnable，在所有线程到达 Barrier 后，但是在释放（让他们继续运行）之前。]. This barrier action is useful for updating shared-state before any of the parties continue[为什么要有这个 Runnable ？可以在所有线程继续运行前更新共享状态等].

If the barrier action does not rely on the parties being suspended when it is executed, then any of the threads in the party could execute that action when it is released. To facilitate this, each invocation of await() returns the arrival index of that thread at the barrier. You can then choose which thread should execute the barrier action, for example:

	if (barrier.await() == 0) { 
		// log the completion of this iteration
	}

The CyclicBarrier uses an all-or-none breakage model for failed synchronization attempts: If a thread leaves a barrier point prematurely(提前) because of interruption, failure, or timeout, all other threads waiting at that barrier point will also leave abnormally via BrokenBarrierException (or InterruptedException if they too were interrupted at about the same time).[要么全体成功，要么全体失败。和 Future 类似]

Memory consistency effects: Actions in a thread prior to calling await() happen-before actions that are part of the barrier action, which in turn happen-before actions following a successful return from the corresponding await() in other threads.

举一个例子，现在有一个比赛：

每组 5 个人，要把 A 处的球运输到10米外的 B 处，每个人可以拿2个。等10个球全部被运输到 B 处后，这个组就算是完成了任务。那么，只要5个人有一个没有完成，就不能算是完成任务。符合上面 CyclicBarrier 的应用场景。下面是这个例子的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package concurrency;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Player implements Runnable {

    private CyclicBarrier cyclicBarrier;
    private Random rand = new Random(47);

    public Player(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        try {
            // 运输2个球
            TimeUnit.SECONDS.sleep(rand.nextInt(5));

            // 等待其他队友完成
            System.out.println(Thread.currentThread() + " 完成任务！等待队友 ing...");
            cyclicBarrier.await();
        } catch (BrokenBarrierException e) {
            System.out.println("BrokenBarrierException " + e);
        } catch (InterruptedException e) {
            System.out.println("InterruptedException " + e);
        }
    }
}

public class CyclicBarrierGame {
    public static void main(String[] args) {
        //定义 CyclicBarrier
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                //全部完成
                System.out.println("\n全部完成！ 举手报告 ing...\n");
                System.out.println("谁来执行 Barrier 的 Runnable？(猜测是最后一个) : " + Thread.currentThread());
            }
        });
        
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < 5; i++) {
            exec.execute(new Player(cyclicBarrier));
        }

        /* 下面是为了验证 CyclicBarrier 能够重用
         try {
            TimeUnit.SECONDS.sleep(5);
            for(int i = 0; i < 5; i++) {
            	exec.execute(new Player(cyclicBarrier));
        	}
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        */
        
        exec.shutdown();
    }
}/*output:
Thread[pool-1-thread-3,5,main] 完成任务！等待队友 ing...
Thread[pool-1-thread-2,5,main] 完成任务！等待队友 ing...
Thread[pool-1-thread-5,5,main] 完成任务！等待队友 ing...
Thread[pool-1-thread-1,5,main] 完成任务！等待队友 ing...
Thread[pool-1-thread-4,5,main] 完成任务！等待队友 ing...

全部完成！ 举手报告 ing...

谁来执行 Barrier 的 Runnable？(猜测是最后一个) : Thread[pool-1-thread-4,5,main]
*/

####3. DelayQueue

DelayQueue 就是一个无界队列，是用 PriorityQueue 实现的 BlockingQueue，如果要使用 DelayQueue，其中的元素必须实现 Delayed 接口，Delayed 接口有2个方法需要重写：compareTo()和 getDelay()方法。因为使用的是优先队列，所以需要确定元素之间的优先级，那么重写 compareTo()就很明显了，又为了满足 DelayQueue 的特性（每次队头是延期到期时间最长的元素），那么就需要知道元素的到期时间，而这个时间就是通过 getDelay()获取的。

延迟到期时间最长：这个刚看的时候还挺迷糊的，现在知道了。就是到期之后保存时间最长的元素。比如2个元素，在10:00:00这个时间点都到期了，但是 A 元素到期后保存时间为2分钟，B 元素到期后保存时间为1分钟，那么优先级最高的肯定是 A 元素了（本质来说，这个 order 是通过小顶堆维护的，所以获取延迟到期时间最长元素的时间复杂度为 O(lgN)）。

写了一个例子，但是因为输出有点问题，就看了一下 DelayQueue 的源码，发现里面的实现是委托给 PriorityQueue 的，于是写了篇文章跟了下 PriorityQueue 的基本操作（也是 DelayQueue 的基本操作），结合文档和源码和我给的例子，应该就非常 easy 了：PriorityQueue 源码剖析

####4. PriorityBlockingQueue

哈哈，前面刚看完 PriorityQueue 的源码，这里就遇到了 PriorityBlockingQueue，其实 PriorityBlockingQueue就是用 PriorityQueue 实现的 BlockingQueue，所以没啥可说的。写了个例子低空掠过：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package concurrency;

import java.util.Random;
import java.util.concurrent.PriorityBlockingQueue;

class Leader implements Comparable {
    private String name;
    private int degree;

    public Leader(String name, int degree) {
        this.name = name;
        this.degree = degree;
    }

    @Override
    public int compareTo(Object o) {
        Leader leader = (Leader) o;
        return leader.degree - this.degree;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getDegree() {
        return degree;
    }

    public void setDegree(int degree) {
        this.degree = degree;
    }

}

public class WhoGoFirst {

    // 通过随机数给领导分级别
    private static PriorityBlockingQueue<Leader> leaders = new PriorityBlockingQueue<Leader>();

    public static void watchFilm(Leader leader) {
        leaders.add(leader);
    }

    public static void goFirst(PriorityBlockingQueue<Leader> leaders) {
        try {
            while (!leaders.isEmpty()) {
                Leader leader = leaders.take();
                System.out.println("级别： " + leader.getDegree() + "的 " + leader.getName() + " 正在撤离...");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Random random = new Random();
        for (int i = 1; i <= 10; i++) {
            watchFilm(new Leader("leader " + i, random.nextInt(10)));
        }

        System.out.println("所有领导已经就坐，开始播放电影：速度与激情7...");

        System.out.println("着火了！！！");

        goFirst(leaders);

    }
}/*output:
所有领导已经就坐，开始播放电影：速度与激情7...
着火了！！！
级别： 8的 leader 3 正在撤离...
级别： 7的 leader 8 正在撤离...
级别： 6的 leader 4 正在撤离...
级别： 6的 leader 9 正在撤离...
级别： 6的 leader 2 正在撤离...
级别： 5的 leader 5 正在撤离...
级别： 4的 leader 6 正在撤离...
级别： 4的 leader 7 正在撤离...
级别： 2的 leader 10 正在撤离...
级别： 0的 leader 1 正在撤离...
*/

####5. ScheduledExcutor

这个小节讲的是定时触发任务，知道 crontab 的应该都不陌生。看完以后我 google 了一下，发现几个类似功能的类，先知道有这几个东西，用到了再具体看文档吧。

Timer：单线程轮询任务列表，效率较低
ScheduledExcutor：并行执行
JCrontab：借鉴了 crontab 的语法，其区别在于 command 不再是 unix/linux 的命令，而是一个 Java 类。如果该类带参数，例如com.ibm.scheduler.JCronTask2#run，则定期执行 run 方法；如果该类不带参数，则默认执行 main 方法。此外，还可以传参数给 main 方法或者构造函数，例如com.ibm.scheduler.JCronTask2#run Hello World表示传两个参数 Hello 和 World 给构造函数
Quartz：Spring 就是用的这个执行定时任务的

给个随便搜到的资料：几种任务调度的 Java 实现方法与比较

对于举例子的 ScheduledThreadPoolExecutor，大概看下源码，本质是使用 DelayWorkQueue 实现的 BlockingQueue。其中 DelayWorkQueue 和 DelayQueue 类似，不过没有复用 DelayQueue 中用到的 PriorityQueue，而是自己捯饬了一个新的小（大）顶堆。看来concurrent 也不是100%完美的代码呀，哈哈哈。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ScheduledThreadPoolExecutorTest {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1);
        BusinessTask task = new BusinessTask();
        //1秒后开始执行任务，以后每隔2秒执行一次
        executorService.scheduleWithFixedDelay(task, 1000, 2000,TimeUnit.MILLISECONDS);
    }

    private static class BusinessTask implements Runnable{
        @Override
        public void run() { 
            System.out.println("任务开始...");
            // doBusiness();
            System.out.println("任务结束...");
        }
    }
}

嗯，这个例子虽然简单，但是我想说几点：

ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度：
1. scheduleWithFixedDelay()方法：每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2executeTime+2delay
2. scheduleWithFixedRate()方法：每次执行时间为上一次任务开始起向后推一个时间间隔，即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …
有可能上面的程序执行了一段时间后，会发现不再执行了，去查看日志，可能是doBusiness()方法中抛出了异常。但是为什么doBusiness()抛出异常就会中止定时任务的执行呢？看文档就知道了：

Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next. If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the executor.

简单翻译就是：

创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务的任一执行遇到异常，就会取消后续执行。否则，只能通过执行程序的取消或终止方法来终止该任务。

所以上面的例子应该改成下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ScheduledThreadPoolExecutorTest {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1);
        BusinessTask task = new BusinessTask();
        //1秒后开始执行任务，以后每隔2秒执行一次
        executorService.scheduleWithFixedDelay(task, 1000, 2000,TimeUnit.MILLISECONDS);
    }

    private static class BusinessTask implements Runnable{
        @Override
        public void run() { 
            //捕获所有的异常，保证定时任务能够继续执行
            try{
                System.out.println("任务开始...");
                // doBusiness();
                System.out.println("任务结束...");
            }catch (Throwable e) {
                // solve the exception problem
            }
        }
    }
}

####6. Semaphore

Semaphore 是一个计数信号量，平常的锁（来自 concurrent.locks 或者内建的 synchronized)再任何时刻都只能允许一个任务访问一项资源，但是 Semaphore 允许 N 个任务同时访问这个资源。你还可以将信号量看做是在向外分发使用资源的“许可证”，尽管实际上没有使用任何许可证对象。

总结来说，一般的锁是保证一个资源只能被一个任务访问；Semaphore 是保证一堆资源可以同时有多个任务访问。举个例子，现在有一个厕所，5个坑位，如果使用 synchronized 的话，同步厕所就只能让1个人进入，浪费了4个坑位；稍微往前一步是使用 BlockingQueue（如果你用 synchronized 来同步5个坑位就很复杂多了），再往前一步，concurrent 提供了 Semaphore ，它通过 acquire()和 release()来保证资源的分发使用。

下面我们通过实现一个资源池来说明，具体的场景完全在例子中注释：）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
package concurrency;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

// 抽象成一个资源池
class Pool<T> {
    private int size;
    private List<T> items = new ArrayList<T>();
    private volatile boolean[] checkedOut;
    private Semaphore available;

    // 要放入资源池的资源数目，如果请求线程数目大于资源池资源数目，就需要阻塞等待
    public Pool(Class<T> classObject, int size) {
        this.size = size;
        checkedOut = new boolean[size];
        /**
         * 第二个参数的含义:<br>
         * 
         * true: 代表的是公平竞争<br>
         * 没有第二个参数或者false：代表随机选中等待许可证的线程
         */
        available = new Semaphore(size, true);
        // Load pool with objects that can be checked out:
        for (int i = 0; i < size; i++) {
            try {
                // Assumes a default constructor:
                items.add(classObject.newInstance());
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    public T checkOut() throws InterruptedException {
        available.acquire();
        return getItem();
    }

    public void checkIn(T x) {
        if (releaseItem(x))
            available.release();
    }

    private synchronized T getItem() {
        for (int i = 0; i < size; i++)
            if (!checkedOut[i]) {
                checkedOut[i] = true;
                return items.get(i);
            }
        return null;
    }

    // 回收资源
    private synchronized boolean releaseItem(T item) {
        int index = items.indexOf(item);
        // not in the list
        if (index == -1)
            return false;
        if (checkedOut[index]) {
            checkedOut[index] = false;
            return true;
        }
        return false; // wasn't checked out
    }

}

class Fat {
    private volatile double d; // 阻止指令优化
    private static int counter = 0;
    private final int id = counter++;

    public Fat() {
        // Expensive, interruptible operation
        for (int i = 1; i < 10000; i++) {
            d += (Math.PI + Math.E) / (double) i;
        }
    }

    public void operation() {
        System.out.println(this);
    }

    public String toString() {
        return "Fat id: " + id;
    }

}

class CheckoutTask<T> implements Runnable {
    private static int counter = 0;
    private final int id = counter++;
    private Pool<T> pool;

    public CheckoutTask(Pool<T> pool) {
        this.pool = pool;
    }

    @Override
    public void run() {
        try {
            T item = pool.checkOut();
            System.out.println(this + "checked out " + item);
            TimeUnit.SECONDS.sleep(1);
            System.out.println(this + "checked in " + item);
            pool.checkIn(item);
        } catch (InterruptedException e) {
            // 终止
        }
    }

    @Override
    public String toString() {
        return "checkoutTask " + id + " ";
    }
}

public class SemaphoreDemo {
    final static int SIZE = 25;

    public static void main(String[] args) throws Exception {
        // 创建一个 Fat 的资源池，大小为25
        final Pool<Fat> pool = new Pool<Fat>(Fat.class, SIZE);

        // 启动25个线程开始玩，从25个资源池 checkout
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < SIZE; i++) {
            exec.execute(new CheckoutTask<Fat>(pool));
        }
        System.out.println("All CheckoutTasks created");

        // 然后用主线程把所有的 Fat 全灌到 list 中了，资源池为空
        List<Fat> list = new ArrayList<Fat>();
        for (int i = 0; i < SIZE; i++) {
            Fat fat = pool.checkOut();
            System.out.println(i + ": main() thread checked out ");
            fat.operation();
            list.add(fat);
        }

        // 还记得 Future 会阻塞吗？因为主线程把25个资源全 checkout 了，所以再 checkOut 肯定阻塞了
        Future<?> blocked = exec.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    // Semaphore prevents additional checkout,
                    // so call is blocked:
                    pool.checkOut();
                } catch (InterruptedException e) {
                    System.out.println("checkOut() Interrupted");
                }
            }
        });
        // 因为 Semaphore 是阻塞的，所以10s 还拿不到的情况下，就取消 blocked 线程的工作
        TimeUnit.SECONDS.sleep(10);
        blocked.cancel(true); // Break out of blocked call
        System.out.println("\n\n\nChecking in objects in " + list);
        for (Fat f : list) {
            pool.checkIn(f);
        }
        for (Fat f : list) {
            pool.checkIn(f); // Second checkIn ignored
        }
        exec.shutdown();
    }

}/*output:
checkoutTask 1 checked out Fat id: 1
checkoutTask 4 checked out Fat id: 4
checkoutTask 3 checked out Fat id: 3
checkoutTask 5 checked out Fat id: 5
checkoutTask 2 checked out Fat id: 2
checkoutTask 6 checked out Fat id: 6
checkoutTask 0 checked out Fat id: 0
checkoutTask 7 checked out Fat id: 7
checkoutTask 8 checked out Fat id: 8
checkoutTask 9 checked out Fat id: 9
checkoutTask 10 checked out Fat id: 10
checkoutTask 11 checked out Fat id: 11
checkoutTask 12 checked out Fat id: 12
checkoutTask 13 checked out Fat id: 13
checkoutTask 14 checked out Fat id: 14
checkoutTask 15 checked out Fat id: 15
checkoutTask 16 checked out Fat id: 16
checkoutTask 17 checked out Fat id: 17
checkoutTask 18 checked out Fat id: 18
checkoutTask 19 checked out Fat id: 19
checkoutTask 20 checked out Fat id: 20
checkoutTask 21 checked out Fat id: 21
checkoutTask 22 checked out Fat id: 22
checkoutTask 23 checked out Fat id: 23
All CheckoutTasks created
checkoutTask 24 checked out Fat id: 24
checkoutTask 4 checked in Fat id: 4
checkoutTask 2 checked in Fat id: 2
checkoutTask 0 checked in Fat id: 0
checkoutTask 3 checked in Fat id: 3
checkoutTask 7 checked in Fat id: 7
checkoutTask 9 checked in Fat id: 9
checkoutTask 5 checked in Fat id: 5
checkoutTask 11 checked in Fat id: 11
checkoutTask 12 checked in Fat id: 12
checkoutTask 13 checked in Fat id: 13
checkoutTask 14 checked in Fat id: 14
checkoutTask 15 checked in Fat id: 15
checkoutTask 1 checked in Fat id: 1
checkoutTask 17 checked in Fat id: 17
checkoutTask 16 checked in Fat id: 16
checkoutTask 10 checked in Fat id: 10
checkoutTask 8 checked in Fat id: 8
0: main() thread checked out 
Fat id: 0
1: main() thread checked out 
Fat id: 1
2: main() thread checked out 
Fat id: 2
3: main() thread checked out 
Fat id: 3
4: main() thread checked out 
Fat id: 4
5: main() thread checked out 
Fat id: 5
6: main() thread checked out 
Fat id: 7
7: main() thread checked out 
Fat id: 8
8: main() thread checked out 
Fat id: 9
9: main() thread checked out 
Fat id: 10
10: main() thread checked out 
Fat id: 11
11: main() thread checked out 
Fat id: 12
12: main() thread checked out 
Fat id: 13
13: main() thread checked out 
Fat id: 14
14: main() thread checked out 
Fat id: 15
15: main() thread checked out 
Fat id: 16
16: main() thread checked out 
Fat id: 17
checkoutTask 6 checked in Fat id: 6
checkoutTask 18 checked in Fat id: 18
checkoutTask 20 checked in Fat id: 20
checkoutTask 21 checked in Fat id: 21
checkoutTask 22 checked in Fat id: 22
checkoutTask 23 checked in Fat id: 23
checkoutTask 24 checked in Fat id: 24
17: main() thread checked out 
Fat id: 6
18: main() thread checked out 
Fat id: 18
19: main() thread checked out 
Fat id: 20
20: main() thread checked out 
Fat id: 21
checkoutTask 19 checked in Fat id: 19
21: main() thread checked out 
Fat id: 22
22: main() thread checked out 
Fat id: 19
23: main() thread checked out 
Fat id: 23
24: main() thread checked out 
Fat id: 24
checkOut() Interrupted



Checking in objects in [Fat id: 0, Fat id: 1, Fat id: 2, Fat id: 3, Fat id: 4, Fat id: 5, Fat id: 7, Fat id: 8, Fat id: 9, Fat id: 10, Fat id: 11, Fat id: 12, Fat id: 13, Fat id: 14, Fat id: 15, Fat i
d: 16, Fat id: 17, Fat id: 6, Fat id: 18, Fat id: 20, Fat id: 21, Fat id: 22, Fat id: 19, Fat id: 23, Fat id: 24]
*/

####7. Exchanger

终于来到21.7小节的最后一个构件了！！！！

这个构件很简单，是为了让两个任务交换对象，当两个任务进入 Exchanger 提供的“栅栏”时，他们各自拥有一个对象，当它们离开时，都拥有了之前由对方拥有的对象。为什么要有这么个东西呢？考虑下面的场景：

一个任务在创建对象，这些对象的生产/销毁代价都非常高。上面 Semaphore 的例子还算靠谱，因为我用完了资源并没有销毁，直接还给资源池了，然后立马可以被复用。但是如果两个线程需要知晓对方的工作状态信息，就可以用 Exchanger 交换各自的工作状态。

更具体的使用场景还没有仔细想，大概搜了下都是缓存交换（一个读，一个写），比如这个：java.util.concurrent.Exchanger应用范例与原理浅析。我只是简单写了个 demo 备忘，用到的时候知道有这个东西，其他的再看文档吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
package concurrency;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Exchanger;

public class ExchangerTest {

    public static void main(String[] args) {
        Exchanger<List<Integer>> exchanger = new Exchanger<>();
        new Consumer(exchanger).start();
        new Producer(exchanger).start();
    }

}

class Producer extends Thread {
    List<Integer> list = new ArrayList<>();
    Exchanger<List<Integer>> exchanger = null;

    public Producer(Exchanger<List<Integer>> exchanger) {
        super();
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("this is Producer");
        Random rand = new Random();
        for (int i = 0; i < 1; i++) {
            list.clear();
            list.add(rand.nextInt(10000));
            list.add(rand.nextInt(10000));
            list.add(rand.nextInt(10000));
            list.add(rand.nextInt(10000));
            list.add(rand.nextInt(10000));
            try {
                System.out.println("producer exchanger...");
                list = exchanger.exchange(list);
                System.out.println("Producer is done");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer extends Thread {
    List<Integer> list = new ArrayList<>();
    Exchanger<List<Integer>> exchanger = null;

    public Consumer(Exchanger<List<Integer>> exchanger) {
        super();
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("this is Consumer");
        for (int i = 0; i < 1; i++) {
            try {
                System.out.println("consumer blocking...");
                list = exchanger.exchange(list);
                System.out.println("consumer is done");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print(list.get(0) + ", ");
            System.out.print(list.get(1) + ", ");
            System.out.print(list.get(2) + ", ");
            System.out.print(list.get(3) + ", ");
            System.out.println(list.get(4) + ", ");
        }
    }
}/*output:
this is Consumer
consumer blocking...
this is Producer
producer exchanger...
Producer is done
consumer is done
7481, 9360, 6010, 4630, 4338, 
*/

Enjoy Running

Sun, 01 Mar 2015 00:00:00 +0000

今天是周日，来上班后的第一个周末。周四和周五北京天气晴朗，加上膝盖都特么恢复一年多了，各种蠢蠢欲动，想去奥森刷圈。结果周六一起床就发现下大雪了。。。WTF!!!跟同事吃饭抱怨了好久，晚上也赖到12点才睡觉。。。万万没想到，第二天6点多竟然被阳光照！醒！了！！往窗外一看，雪完全化了。于是果断起床、洗漱冲向奥森。

一进奥森吓一大跳，门口人超多，而且都是光穿一个短裤，身上、脸上画的五花八门，一堆长短炮在拍照。。。不是太喜欢热闹的地方，就开始简单热身，慢跑了1公里感觉身子热的差不多了。就慢慢加速，可能是将近1年都没跑步吧，到4.5公里处就感觉心跳很快了，看来身体素质确实下降了不少，有点自我感觉良好了。。。。选择了一块草坪休息了大约10分钟，重新再开始就调整了跑步的速度，估计是6-8km/h的样子吧，跑的很舒服。

跑到8km 的时候，膝盖完全没一点不适的感觉，很出乎我的意料。不过悲剧的是右胯很酸痛，直接导致跑的时候略疼，很难受，估计是这次强度有点大的缘故吧，就走完了剩下的2.5km。之后在南门入口的大草坪上躺了一个多小时，虽然上面挺多杂草，但是跑完步酣畅淋漓就管不了那么多了。。。

放一张照片吧：）

虽然这次直接上10公里有点累（中午心情好，吃了一顿大餐，然后从3点睡到6点），但是跑步那种酣畅淋漓的感觉又回来了，超级舒服啊！！希望今年能重新开始跑步，初步计划是每周去奥森刷一次。而且也加入了百度跑协，说不定还能叫上几个人一起跑，那估计更爽吧，哈哈哈哈哈哈哈哈哈哈哈哈哈哈。如果可能，我还想参加今年的北马！！啊，想想都有点小激动呢。I love running…

Java编程思想 - 第二十一章、并发（五）

Mon, 16 Feb 2015 00:00:00 +0000

###21.6 线程死锁

关于死锁的问题，是非常麻烦的。对一般程序而言，如果马上出问题，你就可以立即跟踪下去。但是线程死锁不会马上出问题，看起来工作良好的程序却具有潜在的死锁风险。因此，在编写并发程序的时候，进行仔细的程序设计以防止死锁是关键部分。

先解释一下线程死锁吧：

某个任务在等待另一个任务，而后者又等待别的任务，这样一直下去，直到这条链条上的任务又在等待第一个任务释放锁。这得到了一个任务之间相互等待的连续循环，没有哪个线程能继续运行，这就被称为线程死锁。

####1. 哲学家进餐

哲学家进餐是一个典型的线程死锁例子，我就不多描述场景了，直接上程序模拟(省略了一些 import 语句，请自行添加)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
class Chopstick {
    private boolean taken = false;
    
    public synchronized void take() throws InterruptedException {
        while(taken) {
            wait();
        }
        
        taken = true;
    }
    
    public synchronized void drop() {
        taken = false;
        notifyAll();
    }
}

/**
 * 每个哲学家都是一个 Runnable 任务
 */
class Philosopher implements Runnable {

    private Chopstick left;
    private Chopstick right;
    private final int id;
    private final int ponderFctor;
    private Random rand = new Random(47);

    public Philosopher(Chopstick left, Chopstick right, int id, int ponder) {
        this.left = left;
        this.right = right;
        this.id = id;
        this.ponderFctor = ponder;
    }

    // 思考的时间
    private void pause() throws InterruptedException {
        //不思考
        if (ponderFctor == 0) {
            return;
        }
        TimeUnit.MILLISECONDS.sleep(rand.nextInt(ponderFctor * 250));
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // 思考
                System.out.print(this + " thinking...");
                pause();
                
                // 饿了
                System.out.println(this + " grabbing right");
                right.take();
                System.out.println(this + " garbbing left");
                left.take();
                System.out.println(this + " eating...");
                pause();
                
                //吃完了
                right.drop();
                left.drop();

            }
        } catch (InterruptedException e) {
            System.out.println(this + " exiting via interrupt");
        }
    }

    @Override
    public String toString() {
        return "Philosopher " + id + "号";
    }
}

/**
 * Args: 0 5 timeout
 * 
 *  0:是思考时间的因子
 *  5:筷子数目
 *  timeout:停止时间
 */
public class DeadlockingDiningPhilosophers {
    public static void main(String[] args) throws Exception {
        int ponder = 5;
        if (args.length > 0) {
            ponder = Integer.parseInt(args[0]);
        }
        int size = 5;
        if (args.length > 1) {
            size = Integer.parseInt(args[1]);
        }

        ExecutorService exec = Executors.newCachedThreadPool();
        Chopstick[] chopsticks = new Chopstick[size];
        for (int i = 0; i < size; i++) {
            chopsticks[i] = new Chopstick();
        }
        for (int i = 0; i < size; i++) {
            exec.execute(new Philosopher(chopsticks[i], chopsticks[(i + 1) % size], i, ponder));
        }
        if (args.length == 3 && args[2].equals("timeout")) {
            TimeUnit.SECONDS.sleep(5);
        } else {
            System.out.println("Press 'Enter' to quit");
            System.in.read();
        }
        exec.shutdownNow();
    }
}

这个程序不指定参数的话，就是0 5，然后按 Enter 停止；如果指定0 5 timeout，就在5s 后自动停止。不过悲催的是，我运行了几十次，一共就产生了1次死锁。。。其中有次运行了3个小时也没死锁 T_T 可见死锁问题的隐蔽性啊。

那么，死锁问题是不可能避免的吗？Nope.其实线程死锁必须同时满足以下四个条件（一定是同时）：

互斥条件。各个任务使用的资源至少有一个是不同共享的，属于临界资源。比如上面的筷子
至少有一个任务必须占有资源的同时想获取另外一个或可用或被其他任务占用的资源
资源不能被抢占。意思是大家都平等，不能强行抢夺别人的资源
必须有循环等待。就像开头描述的那样，大家要形成一个闭环

因为发生死锁要同时满足四个条件，那么解除死锁只需要破坏其中的一个即可。一般情况下，最容易防止死锁的方法是破坏第四个条件。

比如上面的哲学家就餐问题，第四个条件是因为哲学家都先拿右边，然后拿左边。因为是圆桌，所以最后一个哲学家和第一个哲学家就会抢占它们中间的筷子形成闭环。解决方法很简单：如果最后一个哲学家被初始化为先拿左边的筷子，然后再拿右边的筷子，那么这个哲学家将永远不会阻止他右边的哲学家拿起筷子。

####2. 本节习题

这个小节有一个习题，说的是把筷子集中放到一个容器中，每个哲学家要就餐的话，就取出两根筷子，用完就放进去。这样能防止死锁吗？

关于死锁的问题，一定要往四个条件上靠拢。所以，我们看看他能破坏哪个条件，如果破坏了任意一个，就一定能解决死锁。那我们逐一分析：

互斥条件：满足。两根筷子要么在容器中，要么在哲学家手中。不能共享
占着一个，想要另外一个：Bingo！因为我只要拿到筷子，就一定是两根，而且不会再去拿容器中的筷子。所以这个条件不满足
资源不能被抢占：满足。
循环等待：没有循环等待，因为两根筷子捆绑一会，只有一种情况，拿或者没拿。不会产生循环

综上，从第二条我们就知道，这种方法不会产生死锁。官方答案是这样的：

We use ChopstickQueue to create the ChopstickBin, so it gains all of LinkedBlockingQueue’s control logic. Instead of picking up the left and right chopsticks, philosophers take them from a common bin, an activity we suspend when too few chopsticks remain. The results are the same, with the flaw that an equal number of chopsticks and philosophers can quickly deadlock, but a single extra chopstick prevents this.

很悲催，我们想错了。那么错在哪里了？

其实是理解错题意了。囧 rz。人家没说一次拿两根，而是拿完一根再拿一根。。。。。。。那么，5个哲学家、5根筷子，启动时，所有哲学家都饿了，同时去拿1根。。。然后就悲剧了。。。同时4条件也满足了。所以，如果是拿两根筷子作为一个原子操作，就不会产生死锁了。

####3. 拓展阅读

以前写过一个 HashMap 死锁的问题，就是因为多线程并发造成的。觉得还是趁机再巩固一下的好：）

HashMap 死锁分析

Java编程思想 - 第二十一章、并发（四）

Sun, 01 Feb 2015 00:00:00 +0000

###21.5 多个线程之间如何协作？

前面对线程进行了讨论，但是比较简单，要么是每个线程独享自己线程内部的资源，要么是用锁机制串行访问共享资源。而本小节做了一点点升级：使用共享资源不再是盲目的阻塞了，而是使用新的握手机制，其实握手类似事件驱动。不过我对事件驱动也只是了解个皮毛，知道大概的 select/kqueue/epoll 原理，具体的还请自行 man 或者 google。我简单举个例子吧：

首先要理解阻塞：阻塞是什么呢？假如现在有个快递（共享资源），但是你不知道什么时候能送到自己手里，而且你没有别的事可以干（或者说接下来的事要等快递来了才能做）。那么你可以去睡觉了，因为你知道快递把货送来时一定会给你打个电话（假定一定能叫醒你）
然后是非阻塞忙轮询：如果用忙轮询的方法，那么你需要知道快递员的手机号，然后不停地给他打电话：“你到了没？”

这样一看，我们在前面学习的就是阻塞（synchronized 锁）或者非阻塞忙轮询（使用 while(资源不可用) {sleep…}）。这样做不仅效率低，还会大大降低效率，因为对于线程来说，不仅需要保存线程上下文，还要频繁的切换用户态和内核态。而这里解决方法就类似 epoll 那样的回调。

线程协作简单来说就是对共享资源的使用还是阻塞，但是一旦共享资源释放，会主动给阻塞线程发送信号。这样就不用傻傻等待或者不停轮询了。而协作的关键就是如何传递这个信号，在 Java 中我们可以使用 Object 中的 wait()和 notify()/notifyAll()函数，也可以使用 concurrent 类库中提供的 await()和 signal()/signalAll()函数。

下面我们就来具体学习线程协作的相关知识。如果先大致浏览这一小节的话，会发生节奏非常紧凑：

第一小节首先介绍线程协作，以及相关的3个函数： wait()、notify()、notifyAll()，然后用一个凃蜡、喷漆程序演示如何进行线程协作（重点是明白线程为什么可以协作呢？因为 wait()不会一直占有锁，在挂起期间会允许进入其他 synchronized 方法改变条件，从而 notify()后再醒来继续工作）
notify()和 notifyAll()的区别（个人感觉这一节讲的很迷糊，可以自己去 stackoverflow 或者其他地方查资料）
用厨师做菜、服务员上菜演示生产者消费者模型，其实还包括一个用 Lock 和 Condition 实现的凃蜡、喷漆程序，可以和第一小节再对比一下
使用同步队列的方式改变第三小节的生产者消费者模型，用一个队列解耦生产者和消费者
使用管道来进行输入/输出，本质上是生产者消费者模型的变体，不过它是存在于引入 BlockingQueue 之前的 Java 版本，所以能用 BlockingQueue 的地方就可以忘掉管道了

大概了解本节内容之后，就可以进行有的放矢的学习了：）

####1. wait()和 notifyAll()的使用

话说被书上这个例子坑的很惨，这个例子前前后后看过10遍左右吧，每次看到这都要纠结很久。这次也是弄了好久才算没那么迷糊。。。。。。（智商急需充值啊。。。）嗯，我先来描述这个“简单”的程序吧：

现在有一辆车，需要对它进行凃蜡和抛光操作。因为存在先后顺序，所以必须先凃蜡，然后在抛光。

场景说完了，show code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Car {
	/**
	 * true： 凃蜡<br>
	 * false：抛光
	 */
	private boolean waxOn = false;

	// 完成凃蜡，可以进行抛光了
	public synchronized void waxed() {
		waxOn = true;
		notifyAll();
	}

	// 完成抛光，可以进行下一层凃蜡了
	public synchronized void buffed() {
		waxOn = false;
		notifyAll();
	}

	// 这里为什么要用 while()不断监测？为什么不用 if()？
	public synchronized void waitForWaxing() throws InterruptedException {
		while (waxOn == false) {
			wait();
		}
	}

	public synchronized void waitForBuffing() throws InterruptedException {
		while (waxOn == true) {
			wait();
		}
	}
}

// 凃蜡任务。因为凃蜡肯定先发生，所以步骤为凃蜡-等待抛光-凃蜡
class WaxOn implements Runnable {
	private Car car;
	public WaxOn(Car c) {
		this.car = c;
	}
	public void run() {
		try {
			while(!Thread.interrupted()) {
				System.out.println("开始凃蜡...");
				TimeUnit.MILLISECONDS.sleep(200);
				car.waxed();
				car.waitForBuffing();
			}
 		} catch(InterruptedException e) {
 			System.out.println("Exit via interrupt");
 		}
		System.out.println("结束凃蜡任务");
	}
}

// 抛光任务。先行任务为凃蜡，所以步骤为等待凃蜡-抛光-等待凃蜡
class WaxOff implements Runnable {
	private Car car;
	public WaxOff(Car car) {
		this.car = car;
	}
	public void run() {
		try {
			while(!Thread.interrupted()) {
				car.waitForWaxing();
				System.out.println("开始抛光...");
				TimeUnit.MICROSECONDS.sleep(200);
				car.buffed();
			}
		} catch(InterruptedException e) {
			System.out.println("Exit via interupt");
		}
		System.out.println("结束抛光任务");
	}
}

/*
 * 特意先开始抛光任务，再开始凃蜡任务
 */
public class WaxOMatic {
	public static void main(String[] args) throws InterruptedException {
		Car car = new Car();
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(new WaxOff(car));
		exec.execute(new WaxOn(car));
		TimeUnit.SECONDS.sleep(5);
		exec.shutdownNow();
	}
}

整个程序的逻辑很简单，但是一定要理解 boolean 类型的 waxOn 变量所代表的含义。其实我到现在也没明白。。。。。。。。不过不影响看懂整个程序的逻辑：

首先定义一个车，waxed()代表凃蜡完成，buffed()代表抛光完成。waitForWaxing()等待凃蜡，如果 waxOn = false 就说明还在抛光；waitForBuffing()等待抛光，如果 waxOn = true 就说明还在凃蜡。（但是waxOn 究竟代表完成，还是进行中呢？如果代表完成，那么 waitForWaxing()的 waxOn = false 就代表抛光完成，可以进行凃蜡了。明明可以工作了好吗！！！竟然是 wait()。正好和我理解的相反；如果理解成进行中，那么 waxed()中又立即调用了 notifyAll()，明显是完成了凃蜡的意思。）
WaxOn 就是凃蜡了，因为这个肯定是起始动作。所以 run()中先进行凃蜡，然后等待抛光
WaxOff 就是抛光了，因为它肯定在凃蜡操作后执行，所以 run()中先等凃蜡完成后才能进行抛光操作，抛光完成后就再等待下一次凃蜡完成。
main()为了突出这个逻辑，特意先调用了抛光过程，这个希望你能注意到（感觉作者对每个例子都好用心的T_T）

一定要多看看其中是如何使用 wait()和 nofityAll()，如果能提出问题就更好了。一个非常值得思考的问题是：为什么 wait()要使用 while()去监测，既然 notifyAll()发送了资源可用的信号，那么 wait()收到这个消息，用 if()就足够了呀。这是为什么呢？原因如下：

可能有多个任务出于相同的原因在等待同一个锁，而第一个唤醒任务可能会改变这种状况（即使你没有这么做，有人也会通过继承你的类去这么做）。如果属于这种情况，那么这个任务应该被再次挂起，直至其感兴趣的条件发生变化
在这里任务从其 wait()中被唤醒的时刻，有可能会有某个其他的任务已经做出了改变，从而使得这个任务在此时不能执行，或者执行其操作已经显得无关紧要。此时，应该通过再次调用 wait()来将其重新挂起。
也有可能某些任务出于不用的原因在等待你的对象上的锁（在这种情况下必须使用 notifyAll())。在这种情况下，你需要检查是否已经由正确的原因唤醒，如果不是，就再次调用 wait()。

因此，总结一下上面的要点：

其本质就是要检查所感兴趣的特定条件，并在条件不满足的情况下返回到 wait()中。惯用的方法就是使用 while 来编写 wait()的代码。而且 wait()有两种使用，一种是指定到期时间，一种是无限等待。一般情况下我们都会使用无限等待，因为条件很多情况下是无法得知改变的大概时间的。

然后还有一个有趣的问题：wait()/notify()/notifyAll()既然都是关于线程协作方面的，为什么它们是在基类 Object 中实现而不是 Thread 中实现呢？

尽管乍一想有点奇怪，但是我们来分析一下。锁存在于所有对象的对象头中，所以任何同步控制的地方都用到了锁，而用到锁的地方当然也可以进行线程协作。如果把这3个方法实现在 Thread 中，那么使用线程协作的范围就会缩小到继承了 Thread 或者实现了 Runnable 接口的类的对象中，而不是所有对象。实际上，也只能在同步控制块中调用 wait()、notify()、notifyAll()，因为它们都和锁关联，而 sleep()因为不用操作锁，所以可以在非同步控制方法中调用，如果在非同步控制方法中调用了这3个方法，程序能够通过编译，不过在运行的时候，将得到 IllegalMonitorStateException 异常，并伴随着一些含糊的信息，比如“当前线程不是拥有者”。消息的意思是，调用 wait()、notify()、notifyAll()的任务在调用这些方法前必须“拥有”（获取）对象的锁。

####2. 虽然使用了 notifyAll(),但是信号一定能被 wait()收到吗？——错失的信号

当线程使用 wait()/notify()或者 wait()/notifyAll()时，均可能发生错失信号的问题。想想这是什么原因呢？比如下面这段代码你能看出问题吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
T1:
	synchronized(sharedMonitor) {
		<setup condition for T2>
		shareMonitor.notify();
	}

T2:
	while(someCondition) {
		//Point 1
		synchronized(sharedMonitor) {
			sharedMonitor.wait();
		}
	}

两个线程 T1和 T2的协作正确吗？如果不正确，会发生什么问题呢？

其实代码中已经有了提示，在 Point 1处可能会发生错误。假如 T2执行到 Point 1的时候，说明someCondition 为 true，而这时线程调度器将时间片分给 T1，T1检查 sharedMonitor 对象锁没有占用，就拿到锁进入到同步控制块中，改变T2 线程的 while 条件，然后发送一个信号。但是因为 T2已经执行过 someCondition 的判断，所以就错失了 notify（）的通知，在同步控制块中 wait（）导致死锁（一直等待）。

那么，解决办法是防止在 someCondition 上产生变量竞争条件。不竞争不就是串行的意思嘛，所以 T2的代码将 while()放在同步控制块中即可：

1
2
3
4
5
	synchronized(sharedMonitor) {
		while(someCondition) {
			sharedMonitor.wait();
		}
	}

####3. notify() VS notifyAll()

如果仔细观察上面的程序，会发现我们一会用 notifyAll()一会用 notify(),那么它们各自的使用场景是什么？

其实从名字可以猜个大概，notify()是对于单个线程来说的，notifyAll()是对于所有线程而言的。举个例子，现在大家都在教室自习，有个家长来找自己的孩子，那么 notify()就是去那个家长的孩子座位上单独告诉他，notifyAll()就是在班里大吼一声某某的家长在外面，让所有学生都知道，然后某某出去，其他孩子继续干自己的事情。

实际上，notify()和 notifyAll()的区别还是非常值得研究的，stackoverflow 上也有这个问题的讨论：Java: notify() vs. notifyAll() all over again

####4. 生产者与消费者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Meal {
    private final int orderNum;

    public Meal(int orderNum) {
        this.orderNum = orderNum;
    }

    public String toString() {
        return "Meal " + orderNum;
    }
}

class Waiter implements Runnable {

    private Restaurant restaurant;

    public Waiter(Restaurant restaurant) {
        this.restaurant = restaurant;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (restaurant.meal == null) {
                        wait();
                    }
                }
                System.out.println("Waiter got " + restaurant.meal);
                // 为什么要选择 chef 作为同步控制块的锁呢？
                // 废话，想通知 chef，肯定要调用 chef.notifyAll()。因为 notifyAll()必须在
                // 同步控制块中调用，而且释放的是 chef 的锁，肯定需要先获取 chef 的锁了。。。
                synchronized (restaurant.chef) {
                    restaurant.meal = null;
                    restaurant.chef.notifyAll(); // 准备下一道菜
                }
            }
        } catch (InterruptedException e) {
            System.out.println("Waiter interrupted");
        }
    }
}

class Chef implements Runnable {

    private Restaurant restaurant;
    private int count = 0;

    public Chef(Restaurant restaurant) {
        this.restaurant = restaurant;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (restaurant.meal != null) {
                        wait();
                    }
                }

                if (++count == 11) {
                    System.out.println("菜上齐了");
                    //这块只是向 chef 和 waiter 发送一个 interrupt 信号
                    //但是因为 synchronized 和 IO 是不能被中断的，所以这里会通过可中断的
                    //sleep()抛出 InterruptedException。
                    //而 waiter 只能通过 while(Thread.interrupted())抛出的 InterruptedException返回
                    
                    //而且我们会发现，多做了一个菜！本来做了10个就够了。11个本意想关闭程序，但是因为
                    //synchronized 无法中断，只好又做了一个菜（厨师也饿了）。但是因为服务员在 wait()，可以被中断
                    //所以做好的菜没有被服务员上去。。。。
                    restaurant.exec.shutdownNow();
                }

                System.out.print("做菜ing...");
                synchronized (restaurant.waiter) {
                    restaurant.meal = new Meal(count);
                    restaurant.waiter.notifyAll();
                }

                TimeUnit.MILLISECONDS.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("chef interrupted");
        }
    }
}

public class Restaurant {
    Meal meal;
    ExecutorService exec = Executors.newCachedThreadPool();
    Waiter waiter = new Waiter(this);
    Chef chef = new Chef(this);

    public Restaurant() {
        exec.execute(chef);
        exec.execute(waiter);
    }

    public static void main(String[] args) {
        new Restaurant();
    }
}/*output:
做菜ing...Waiter got Meal 1
做菜ing...Waiter got Meal 2
做菜ing...Waiter got Meal 3
做菜ing...Waiter got Meal 4
做菜ing...Waiter got Meal 5
做菜ing...Waiter got Meal 6
做菜ing...Waiter got Meal 7
做菜ing...Waiter got Meal 8
做菜ing...Waiter got Meal 9
做菜ing...Waiter got Meal 10
菜上齐了
Waiter interrupted
做菜ing...chef interrupted
*/

这个程序的输出会发现，最后一道菜已经做了，但是没有上。写完迷糊了好久才想起来，synchronized 不可被中断，但是 wait()可以被中断啊（同时中断状态被清除，抛出一个 InterruptedException）！！！！

####5. 生产者-消费者与队列

上面是生产者消费者模型的最基本实现——厨师做完一道菜后通知服务员取菜，服务员取菜之后通知厨师做菜。这样的做法太低效，因为每次交互都需要握手。在更高效的程序中，可以使用同步队列来解决任务协作问题，同步队列在任何时刻都只允许一个任务插入或移除元素。在 java.util.concurrent.BlockingQueue 接口中提供了这种队列，这个接口有大量的标准实现。通常可以使用 LinkedBlockingQueue，它是一个无界队列，还可以使用 ArrayBlockingQueue，它又固定的大小，因此可以在它被阻塞之前向其中放置有限数量的元素。

并且，使用同步队列可以简化上面繁琐的握手方式。如果消费者任务试图从队列中获取元素，而该队列为空，那么这些队列还可以挂起消费者任务，当有更多的元素可用时，又会恢复消费者任务。阻塞队列可以解决非常大量的问题，而方式与 wait()和 notifyAll()相比，则简单可靠的多。

下面我们写一个简单的程序说明一下 BlockingQueue 的使用方法，以及它带来的便利。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package concurrency;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.SynchronousQueue;

class LiftOffRunner implements Runnable {
    private BlockingQueue<LiftOff> rockets;

    public LiftOffRunner(BlockingQueue<LiftOff> rockets) {
        this.rockets = rockets;
    }

    //生产者
    public void add(LiftOff lo) {
        try {
            rockets.put(lo);
        } catch(InterruptedException e) {
            System.out.println("Interrupted during put()");
        }
    }
    
    //消费者——注意后面的程序先启动了消费者。
    public void run() {
        try {
            while(!Thread.interrupted()) {
                LiftOff rocket = rockets.take();
                rocket.run();
            }
        } catch(InterruptedException e) {
            System.out.println("waking from take()");
        }
        System.out.println("Exiting LiftOffRunner");
    }
}

public class TestBlockingQueues {
    /**
     * 其实getkey()仅仅是为了隔开 BlockingQueue 的不同实现类。
     */
    static void getkey() {
        try {
            new BufferedReader(new InputStreamReader(System.in)).readLine();
        } catch(IOException e) {
            throw new RuntimeException(e);
        }
    }
    
    static void getkey(String message) {
        System.out.println(message);
        getkey();
    }
    
    /**
     * 每次测试一种 BlockingQueue 的实现。其中先调用t.start()是为了启动消费者。
     * 因为没有启动生产者，所以 BlockingQueue 会自动挂起。然后使用 for 循环生产 rockets 的元素。
     * 
     * 所以不仅实例了 BlockingQueue 作为一个 Queue 的使用，也演示了当生产者或者消费者阻塞时，BlockingQueue
     * 会自动帮我们处理，使我们可以专注于业务逻辑。
     */
    static void test(String msg, BlockingQueue<LiftOff> queue) {
        System.out.println(msg);
        LiftOffRunner runner = new LiftOffRunner(queue);
        Thread t = new Thread(runner);
        t.start();
        for(int i = 0; i < 5; i++) {
            runner.add(new LiftOff(5));
        }
        getkey("Press 'Enter' (" + msg + ")");
        t.interrupt();
        System.out.println("Finished " + msg + " test");
    }
    
    public static void main(String[] args) {
        test("LinkedBlockingQueue", new LinkedBlockingDeque<LiftOff>());
        test("ArrayBlockingQueue", new ArrayBlockingQueue<LiftOff>(3));
        test("SynchronousQueue", new SynchronousQueue<LiftOff>());
    }
}

程序的输出需要 System.in，所以自己去运行。运行之后，你的任务是再写一个程序。将厨师、服务员的例子改写成使用 BlockingQueue 的。我也来一发：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;


/**
 * 这个例子的一个收获是：
 * 
 * 想要抛出异常必须得有载体。比如：
 * 
 * while(!Thread.interrupted()) {
 * }
 * 
 * 是不会抛出异常的。
 * 
 * 只有当里面有 sleep()/wait()/join()在运行（让线程处于阻塞状态），然后才能从阻塞状态退出，
 * 并抛出一个 InterruptedException。
 * 
 */

class NewMeal {
    private final int orderNum;

    public NewMeal(int orderNum) {
        this.orderNum = orderNum;
    }

    public String toString() {
        return "Meal " + orderNum;
    }
}

class NewWaiter implements Runnable {
    private RestaurantWithBlockingQueue restaurant;

    public NewWaiter(RestaurantWithBlockingQueue restaurant) {
        this.restaurant = restaurant;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                while (!restaurant.meal.isEmpty()) {
                    NewMeal meal = restaurant.meal.take();
                    System.out.println("Waiter got " + meal);
                }
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted waiter");
        }
    }
}

class NewChef implements Runnable {
    private RestaurantWithBlockingQueue restaurant;

    public NewChef(RestaurantWithBlockingQueue restaurant) {
        this.restaurant = restaurant;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                for (int i = 1; i <= 11; i++) {

                    if (i == 11) {
                        restaurant.exec.shutdownNow();
                        continue;
                    }

                    System.out.println("做菜...");
                    restaurant.meal.add(new NewMeal(i));
                    TimeUnit.MILLISECONDS.sleep(100);
                }
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted chef");
        }
    }
}

public class RestaurantWithBlockingQueue {
    LinkedBlockingQueue<NewMeal> meal = new LinkedBlockingQueue<NewMeal>();
    ExecutorService exec = Executors.newCachedThreadPool();
    NewWaiter waiter = new NewWaiter(this);
    NewChef chef = new NewChef(this);

    public RestaurantWithBlockingQueue() {
        exec.execute(waiter);
        exec.execute(chef);

    }

    public static void main(String[] args) {
//        while(!Thread.interrupted()) {
//            System.out.println("ehl");
//        }
        new RestaurantWithBlockingQueue();
    }
}/*output:
做菜...
Waiter got Meal 1
做菜...
Waiter got Meal 2
做菜...
Waiter got Meal 3
做菜...
Waiter got Meal 4
做菜...
Waiter got Meal 5
做菜...
Waiter got Meal 6
做菜...
Waiter got Meal 7
做菜...
Waiter got Meal 8
做菜...
Waiter got Meal 9
做菜...
Waiter got Meal 10
*/

通过这个程序得出的结论是：

如果线程没有被阻塞，调用 interrupt()将不起作用；若线程处于阻塞状态，就将得到异常（该线程必须事先预备好处理此状况），接着退出阻塞状态。
线程 A 在执行 sleep(),wait(),join()时,线程 B 调用 A 的 interrupt 方法,A会 catch 一个 InterruptedException异常.但这其实是在 sleep,wait,join 这些方法内部不断检查中断状态的值后抛出的 InterruptedException。
如果线程 A 正在执行一些指定的操作时，如赋值、for、while等,线程本身是不会去检查中断状态标志的,所以线程 A 自身不会抛出 InterruptedException 而是一直执行自己的操作。
当线程 A 终于执行到 wait(),sleep(),join()时,这些方法本身会抛出 InterruptedException
若没有调用 sleep(),wait(),join()这些方法,或是没有在线程里自己检查中断状态并抛出 InterruptedException 的话,那么上游是无法感知这个异常的（还记得异常不能跨线程传递吗？）

然后书上还有一个使用 BlockingQueue 的例子，非常简单。本质来说，BlockingQueue 可以当成是一个任务队列，它会自动的搞定同步操作，所以在处理生产者消费者模型时，可以作为首选。当然，使用具体哪种 BlockingQueue 就需要自己选择了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
package concurrency;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

class Toast {
    public enum Status {
        DRY, BUTTERED, JAMMED
    };

    private Status status = Status.DRY;
    private final int id;

    public Toast(int id) {
        this.id = id;
    }

    public void butter() {
        status = Status.BUTTERED;
    }

    public void jam() {
        status = Status.JAMMED;
    }

    public Status getStatus() {
        return status;
    }

    public int getId() {
        return id;
    }

    public String toString() {
        return "Toast " + id + ": " + status;
    }

}

/**
 * ToastQueue 充当别名的作用。就好像 typedef
 *
 */
class ToastQueue extends LinkedBlockingQueue<Toast> {
    
}

//制造吐司
class Toaster implements Runnable {
    
    private ToastQueue toastQueue;
    private int count = 0;
    private Random rand = new Random(47);
    public Toaster(ToastQueue toastQueue) {
        this.toastQueue = toastQueue;
    }
    
    @Override
    public void run() {
        try {
            while(!Thread.interrupted()) {
                TimeUnit.MILLISECONDS.sleep(100 + rand.nextInt(500));
                Toast toast = new Toast(count++);
                System.out.println(toast);
                toastQueue.add(toast);
            }
        } catch(InterruptedException e) {
            System.out.println("制造吐司 is interrupted!");
        }
        System.out.println("Toaster off");
    }
}

//抹黄油
class Butterer implements Runnable {
    
    private ToastQueue dryQueue, butteredQueue;
    public Butterer(ToastQueue dryQueue, ToastQueue butteredQueue) {
        this.dryQueue = dryQueue;
        this.butteredQueue = butteredQueue;
    }
    
    @Override
    public void run() {
        try {
            while(!Thread.interrupted()) {
                Toast toast = dryQueue.take();
                toast.butter();
                System.out.println(toast);
                butteredQueue.put(toast);
            }
        } catch(InterruptedException e) {
            System.out.println("抹黄油 is interrupted!");
        }
        System.out.println("Butterer off");
    }
}

//抹果酱
class Jammer implements Runnable {
    
    private ToastQueue butteredQueue, finishedQueue;
    public Jammer(ToastQueue butteredQueue, ToastQueue finishedQueue) {
        this.butteredQueue = butteredQueue;
        this.finishedQueue = finishedQueue;
    }
    
    @Override
    public void run() {
        try {
            while(!Thread.interrupted()) {
                Toast toast = butteredQueue.take();
                toast.jam();
                System.out.println(toast);
                finishedQueue.put(toast);
            }
        } catch(InterruptedException e) {
            System.out.println("抹果酱 is interrupted!");
        }
        System.out.println("Jammer off");
    }
}

//吃吃吃
class Eater implements Runnable {
    
    private ToastQueue finishedQueue;
    private int count = 0;
    public Eater(ToastQueue finishedQueue) {
        this.finishedQueue = finishedQueue;
    }
    
    @Override
    public void run() {
        try {
            while(!Thread.interrupted()) {
                Toast toast = finishedQueue.take();
                //检查吐司是否按照 order 送来，而且所有都是经过黄油、果酱加工
                if(toast.getId() != count++ || toast.getStatus() != Toast.Status.JAMMED) {
                    System.err.println("Error: " + toast);
                    System.exit(1);
                } else {
                    System.out.println("真好吃啊！！！");
                }
                
            }
        } catch(InterruptedException e) {
            System.out.println("吃吃吃 is interrupted!");
        }
        System.out.println("Eater off");
    }
}

public class ToastMatic {
    public static void main(String[] args) throws Exception {
        ToastQueue dryQueue = new ToastQueue(),
                butteredQueue = new ToastQueue(),
                finishedQueue = new ToastQueue();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new Toaster(dryQueue));
        exec.execute(new Butterer(dryQueue, butteredQueue));
        exec.execute(new Jammer(butteredQueue, finishedQueue));
        exec.execute(new Eater(finishedQueue));
        
        TimeUnit.SECONDS.sleep(5);
        exec.shutdownNow();
    }
}

这个程序虽然简单，但是有几个亮点值得关注：

Toast 是一个使用 enum 的优秀示例
程序中没有显式的 Lock 或者 synchronized 关键字，就显得很简洁。同步全部由同步队列隐式管理了——每个 Toast 在任何时刻都只由一个任务在操作。
因为队列自动进行阻塞、挂起、恢复，就使得程非常简洁，而且省略了 wait()/notifyAll()在类与类之间的耦合，因为每个类都只和它自己的 BlockingQueue 进行通信

####6. 任务间使用管道进行输入/输出

首先需要声明：

这个模型可以看成是生产者-消费者问题的变体，这里的管道就是一个封装好的解决方案。管道基本上是一个阻塞队列，存在于多个引入 BlockingQueue 之前的 Java 版本中。意思很明显，有了 BlockingQueue 之后还是用 BlockingQueue 吧。目测公司的 jdk 都是1.6+吧，所以这个小节基本就是有个印象就好，重点还是掌握 BlockingQueue。

下面这个程序虽然简单，但是最好自己多调试。看看 PipedReader 和 PipedWriter 能不能中断，是 IOException 还是 InterruptedException（其实是java.io.InterruptedIOException）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package concurrency;

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * PipedWriter.write()和 PipedReader.read() 都可以中断，这是和普通 IO 之间最重要的区别了。
 */
class Sender implements Runnable {
    private Random rand = new Random(47);
    private PipedWriter out = new PipedWriter();

    public PipedWriter getPipedWriter() {
        return out;
    }

    @Override
    public void run() {
        try {
            //while (true) {
                for(Integer i = 0; i < 10000000; i++) {
                    out.write(i);
                    //TimeUnit.MILLISECONDS.sleep(rand.nextInt(500));
                }
            //}
        } catch (IOException e) {
            System.out.println(e + " Sender write exception");
        }
//        } catch (InterruptedException e) {
//            System.out.println(e + " Sender sleep interrupted");
//        }
    }
}

class Receiver implements Runnable {
    private PipedReader in;

    //必须和一个 PipedWriter 相关联
    public Receiver(Sender sender) throws IOException {
        in = new PipedReader(sender.getPipedWriter());
    }

    @Override
    public void run() {
        try {
            while (true) {
                //调用 P ipedReader.read()，如果管道没有数据会自动阻塞
                System.out.print("Read: " + (char) in.read() + ", ");
            }
        } catch (IOException e) {
            System.out.println(e + " Receiver read exception");
        }
    }
}

public class PipedIO {
    public static void main(String[] args) throws Exception {
        Sender sender = new Sender();
        Receiver receiver = new Receiver(sender);
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(sender);
        exec.execute(receiver);

        TimeUnit.SECONDS.sleep(1);
        exec.shutdownNow();
    }
}

开头就说了，现在 PipedWriter 和 PipedReader 已经被 BlockingQueue 取代，所以了解即可。记住一点，PipedWriter 和 PipedReader 是可以被中断的。

Java编程思想 - 第二十一章、并发（三）

Thu, 29 Jan 2015 00:00:00 +0000

###21.4 如何优雅的关闭任务？

在任务运行中，不可避免会出现各种情况。那么，对应于任务的关闭，一般有两种方式：

任务正常运行，正常关闭
出现紧急情况，需要终止当前任务

这两种涵盖了所有的情况，正常关闭很简单，它完全是由程序员自己的代码逻辑控制；但是突然中断就比较麻烦，非常容易出错。所以本小节的重点会放在对第二种情况的讨论上，而第二种情况也可以概括一下要点：

线程都有哪些状态呢？
- 新建
- 就绪
- 阻塞
- 死亡
将任务从阻塞状态叫醒：中断机制
先来说 IO 阻塞吧
再来说 synchronized 锁阻塞吧
检查中断

下面我们就来学习一下吧：）

###一、任务正常运行，正常关闭

我们先来看一个书中的例子：

现在有一个公园，它有5个入口。我现在需要统计一段时间内进入公园的人流量。如果是“单线程”做法，我关闭其他4个门，只允许从1个门进入，这个是最简单的但是也是最不人性化的。升级版本是“多线程”，我在每个门做人流统计，然后最后将所有人数加和即可。

下面用程序来模拟这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

//所有入口的总人数
class Count {
	//count 会并发访问，所以 get/set 需要 synchronized 锁起来
	private int count = 0;
	private Random rand = new Random(47);

	//如果去掉 synchronized 那么其中的 temp 和 Thread.yield()会
	//大大增加 increment 失败的几率（也就是并发修改）
	public synchronized int increment() {
		int temp = count;
		if (rand.nextBoolean()) {
			Thread.yield();
		}
		return (count = ++temp);
	}

	public synchronized int value() {
		return count;
	}
}

//每个入口通过 number 各自统计通过当前门的人数
class Entrance implements Runnable {

	private static Count count = new Count();
	private static List<Entrance> entrances = new ArrayList<Entrance>();
	private int number = 0;
	private final int id;
	private static volatile boolean canceled = false;

	public static void cancel() {
		canceled = true;
	}

	public Entrance(int id) {
		this.id = id;
		entrances.add(this);
	}

	// run()的任务就是递增入口人数和总人数，验证 count 的总数是正确的。然后休眠100ms
	@Override
	public void run() {
		while (!canceled) {
			synchronized (this) {
				++number;
			}
			System.out.println(this + " Total: " + count.increment());
			try {
				TimeUnit.MILLISECONDS.sleep(100);
			} catch (InterruptedException e) {
				System.out.println("sleep interrupted");
			}
		}
		System.out.println("stopping " + this);
	}

	public synchronized int getValue() {
		return number;
	}

	public String toString() {
		return "Entrace " + id + ": " + getValue();
	}

	public static int getTotalCount() {
		return count.value();
	}

	public static int sumEntrances() {
		int sum = 0;
		for (Entrance entrance : entrances) {
			sum += entrance.getValue();
		}
		return sum;
	}
}

// 5个门，运行3s 后通过 exec.shutdown()发送 interrupt()中断
public class OrnametalGarden {
	public static void main(String[] args) throws InterruptedException {
		ExecutorService exec = Executors.newCachedThreadPool();
		for (int i = 0; i < 5; i++) {
			exec.execute(new Entrance(i));
		}
		TimeUnit.SECONDS.sleep(3);
		Entrance.cancel();
		exec.shutdown();
		//等待超时时间250ms 后返回 boolean 是否任务终结
		if (!exec.awaitTermination(250, TimeUnit.MILLISECONDS)) {
			System.out.println("some tasks were not terminated");
		}
		System.out.println("Total: " + Entrance.getTotalCount());
		System.out.println("Sum of Entrances: " + Entrance.sumEntrances());
	}
}

例子很简单，我们用一个 Count 来统计最终所有入口的总人数。每个 Entrance 代表一个入口，通过 number 来统计当前入口的人流量。然后我们运行3s 钟之后将整个程序结束，使用的是 volatile 的 canceled 标志。这种方法很正常，在 run()中，累加了 number 和 count，然后休眠100ms 后回到 while()条件中检测 canceled 标志。但是，有的时候，我们需要更紧急的终止任务。

###二、出现紧急情况，需要终止当前任务

下面我们就来重点balabala 阻塞和中断机制吧。

####1. 线程都有哪些状态呢？

在刚才那个问题中，如果线程调用了 sleep()，那么它就处于阻塞状态。线程一共有如下几种状态：

新建：当线程被创建时，它只会短暂的处于这种状态。此时它分配了必须的系统资源，并执行了初始化。此刻线程已经有资格获取 CPU 时间了。之后就靠调度器来调度
就绪：调度器分配时间片了就可以运行，不分配时间片就等待(不是阻塞！)。
阻塞：线程能够运行，但是缺少某个条件。当线程处于阻塞状态，调度器将忽略该线程，不会分配时间片，直到线程重新进入就绪状态
死亡：处于死亡状态的线程是不能再被调度的，并且再也不会得到时间片

那么，通常情况下，线程都会经历新建 - 就绪 - 运行 - 结束的过程，如果有依赖或者外在因素，可能会经历新建 - loop(就绪 - 运行 - 阻塞) - 结束的过程。那么，值得思考的只有一个点：什么情况下线程才会进入阻塞状态呢？

调用了 sleep()方法使任务进入休眠状态
调用了 wait()使线程挂起，直到线程得到了 notify()或者 notifyAll()消息（或者在 Java SE5中的 java.lang.util.concurrent 类库中等价的 signal()或 signalAll()消息），线程才会进入就绪状态
任务等待某个输入/输出
任务视图在某个对象上调用其他同步控制方法，但是对象锁不可用，因为另一个任务已经获取了这个锁

好了，通过上面的讲解。我们知道，有时希望能中终止处于阻塞状态的任务。什么意思呢？比如公园统计人流量的例子中，run()不是休眠100ms，而是100分钟，但是我现在想立即终止所有的统计任务。这怎么办？因为对处于阻塞状态的任务，你不能等待其到达代码中可以检查其状态值的某一点，进而决定让它主动终止，那么唯一的做法就是强制这个任务跳出阻塞状态。

####2. 将任务从阻塞状态叫醒：中断机制

这个概念大家都非常理解，同时对它的棘手性也都感同身受：

早上10点上班，我8点就醒了，一看时间还早，就赖了一会床，8点半起来了，简单洗漱后享用了一顿美味的早餐。9点20出门上班，到公司9点50。啊，惬意的早餐。第二天早上，正在睡梦中的我被闹钟吵醒，拿起闹钟一看，卧槽！！！！9点半了！！！！！火速起床，脸也不洗了，饭也不吃了，提起裤子就跑。到公司门口才发现，工卡没带！！！oh，糟糕的一天啊~~

很形象的例子，其实中断机制也同样麻烦。因为在 Runnable.run()方法的中间打断它，可能需要清理资源（工卡）。因为这一点，Java 的中断机制更像是抛出了异常，因此在 Java 线程中的这种类型的异常中断中用到了异常（这会滑向对异常的不恰当使用，因为这意味着你需要用异常来控制正常的代码逻辑）。为了在阻塞中终止任务，返回一个良好的状态，就必须仔细考虑 catch 子句以正确的清理所有事物。

那么，用代码来完成就用到了 Thread 类的 interrupt 相关函数：

interrupted()
interrupt()
isInterrupted()

我们注意到，新的 concurrent 类库似乎在避免对 Thread 对象的直接操作，转而尽量通过 Executor 来执行所有操作。但是，本质来说，只是 concurrent 的 Executor 帮我们调用了这3个函数，所以还是要学习一下，直接去看文档即可。我简单总结一下这3个方法吧【自己看完文档、总结后再来看我的总结，不然直接看我的总结你还是立马就忘】：

interrupt()——中断一个线程。如果当前线程处于阻塞中（比如调用了 wait()、sleep()、join()等）那么线程中断状态会被清除，并且抛出一个InterruptedException。对于可中断的 I/O 操作也会清除中断状态，抛出一个 ClosedByInterruptedException（还记得前面说过，I/O 是不能中断的吗？注意这里针对的是可中断的 I/O 操作，所以就是后来又提到的 NIO，NIO 可以被中断）。这个是为了替换 Thread.stop()，虽然 stop 已经废弃，但是我们也应该了解 stop 被废弃是因为它中断线程太暴力，like a assault rifle（像一把来福枪的袭击）.这就会导致非原子操作会被直接干掉，很容易出问题。
interrupted()——是一个 static 方法。（被吐槽无数次了，因为命名不规范，导致有很多人用错。）检查线程的中断状态(Thread.status)，但是会清除线程的中断状态，如果你连续调用2次，就会返回 false（当然，是在第一次和第二次之间没有新的 interrupt 的情况下）
isInterrupted()——仅仅检查线程的中断状态，不会清除线程的中断状态
在文档中有个 alive的词让我很困惑：A thread interruption ignored because a thread was not alive at the time of the interrupt will be reflected by this method returning false.在 stackoverflow 上找到了答案：When is a Java thread alive?。意思是线程正在运行 run()方法 is still ongoing.

那么，我们再来看 Executor 是如何帮助我们的：

调用 shutdownNow()将发送一个 interrupt()调用给它启动的所有线程
如果只想中断特定的任务，就要使用 submit()方法而不是 execute()来启动任务，前面说过 Runnable 的 run 是 void 的，而 Callable 的 run 会返回一个 Future<?>。也就是说通过 submit（）调用会持有任务的上下文。因为这里仅仅是为了调用 cancel()而不会调用 get()，所以可以用来中断任务。做法就是讲 true 传递给 cancel()

下面我们就通过使用 ExecutorService 来试试中断是如何工作的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package concurrency;

import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

// Sleep()阻塞
class SleepBlocked implements Runnable {
	@Override
	public void run() {
		try {
			TimeUnit.SECONDS.sleep(100);
		} catch(InterruptedException e) {
			System.out.println("InterruptedException!");
		}
		System.out.println("Exiting SleepBlocked.run()\n");
	}
}

// IO阻塞
class IOBlocked implements Runnable {
	private InputStream in;
	public IOBlocked(InputStream in) {
		this.in = in;
	}
	@Override
	public void run() {
		try {
			System.out.println("Waiting for read():");
			in.read();
		} catch(IOException e) {
			if(Thread.currentThread().isInterrupted()) {
				System.out.println("Interrupted from blocked I/O");
			} else {
				throw new RuntimeException(e);
			}
		}
		System.out.println("Exiting IOBlocked.run()\n");
	}
}

// 同步锁阻塞
class SynchronizedBlocked implements Runnable {
	public synchronized void f() {
		while(true) {
			Thread.yield();
		}
	}
	
	//启动的时候，new 一个线程去抢占锁。
	public SynchronizedBlocked() {
		new Thread() {
			public void run() {
				f();
			}
		}.start();
	}
	@Override
	public void run() {
		System.out.println("Trying to call f()");
		f();
		System.out.println("Exiting SynchronizedBlocked.run()\n");
	}
}

public class Interrupting {
	private static ExecutorService exec = Executors.newCachedThreadPool();
	
	//送出中断
	static void test(Runnable r) throws InterruptedException {
		Future<?> f = exec.submit(r);
		TimeUnit.MILLISECONDS.sleep(100);
		System.out.println("Interrupting " + r.getClass().getName());
		f.cancel(true);
		System.out.println("Interrupt sent to " + r.getClass().getName());
	}
	
	//分别对三中阻塞送出一记漂亮的中断
	public static void main(String[] args) throws InterruptedException {
		test(new SleepBlocked());
		test(new IOBlocked(System.in));
		test(new SynchronizedBlocked());
		TimeUnit.SECONDS.sleep(3);
		System.out.println("Abortin with System.exit(0)");
		System.exit(0);
	}
}/*output:
Interrupting concurrency.SleepBlocked
Interrupt sent to concurrency.SleepBlocked
InterruptedException!
Exiting SleepBlocked.run()

Waiting for read():
Interrupting concurrency.IOBlocked
Interrupt sent to concurrency.IOBlocked
Trying to call f()
Interrupting concurrency.SynchronizedBlocked
Interrupt sent to concurrency.SynchronizedBlocked
Abortin with System.exit(0)
*/

从结果我们可以看到，sleep 是可以被中断的，但是 IO 和 Synchronized 却不能被中断。所以结论是：

能够中断对 sleep()的调用（或者任何要求抛出 InterruptedException 的调用）
不能中断正在试图获取 Synchronized 锁的线程
不能中断正在试图执行 I/O 操作的线程

####3. 先来说 IO 阻塞吧

后两点都比较让人不爽，特别是 I/O，本来硬盘 IO 就慢的要死，阻塞时候还不能中断。这意味着 I/O 具有锁住多线程程序的可能。如果你的程序需要 Low latency，就要特别小心 IO 操作。但幸运的是，各种 NIO（new IO）库提供了更人性化的 IO 中断。被阻塞的 NIO 通道会自动地响应中断，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package concurrency;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousCloseException;
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

class NIOBlocked implements Runnable {
	private final SocketChannel sc;

	public NIOBlocked(SocketChannel sc) {
		this.sc = sc;
	}

	@Override
	public void run() {
		try {
			System.out.println("Waiting for read() in " + this);
			sc.read(ByteBuffer.allocate(1));
		} catch (ClosedByInterruptException e) {
			System.out.println("ClosedByInterruptException");
		} catch (AsynchronousCloseException e) {
			System.out.println("AsynchronousCloseException");
		} catch (IOException e) {
			System.out.println("IOException");
		}
		System.out.println("Exiting NIOBloked.run() " + this);
	}
}

public class NIOinterruption {
	public static void main(String[] args) throws IOException, InterruptedException {
		ExecutorService exec = Executors.newCachedThreadPool();
		//启动一个 Server
		ServerSocket server = new ServerSocket(8080);
		InetSocketAddress isa = new InetSocketAddress("localhost", 8080);
		SocketChannel sc1 = SocketChannel.open(isa);
		SocketChannel sc2 = SocketChannel.open(isa);
		Future<?> f = exec.submit(new NIOBlocked(sc1));
		exec.execute(new NIOBlocked(sc2));
		exec.shutdown();
		TimeUnit.SECONDS.sleep(1);
		f.cancel(true);
		TimeUnit.SECONDS.sleep(1);
		sc2.close();
	}
}/*output:
Waiting for read() in concurrency.NIOBlocked@352fd300
Waiting for read() in concurrency.NIOBlocked@60fe2295
ClosedByInterruptException
Exiting NIOBloked.run() concurrency.NIOBlocked@352fd300
AsynchronousCloseException
Exiting NIOBloked.run() concurrency.NIOBlocked@60fe2295
*/

我们可以看到，IO 阻塞竟然被关闭了！NIO 好屌……

####4. 再来说 synchronized 锁阻塞吧

首先我们知道，如果获取了对象锁，那么就可以无限次的进入这个对象的其他 synchronized 方法，因为锁不是 boolean 而是整型的（前面说过了呦）。所以无论在任何时刻，只要任务以不可中断的方式被阻塞，那么都有潜在的会锁住程序的可能。但是，幸运的是，Java SE5的 concurrent 类库中添加了一个特性，即在 ReentrantLock上阻塞的任务具备可以被中断的能力，这与在 synchronized 方法或临界区上阻塞的任务完全不同：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package concurrency;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BlockedMutex {
	//使用的是重入锁，前面可是说过哦。可以尝试获取锁(时间也可设置)
	private Lock lock = new ReentrantLock();
	public BlockedMutex() {
		lock.lock();
	}
	
	// 但是调用 lock.lockInterruptilby()就可以被中断，抛出 InterruptedException
	// 前面说过，凡是抛出 InterruptedException 的都可以从阻塞状态中断
	public void f() {
		try {
			lock.lockInterruptibly();
			System.out.println("lock acquired in f()");
		} catch(InterruptedException e) {
			System.out.println("Interrupted from lock acquisition in f()");
		}
	}
}

//首先new BlockedMutex()的时候就锁住了 blocked。而且永远不释放，那么 f()就会一直阻塞
class Blocked2 implements Runnable {
	BlockedMutex blocked = new BlockedMutex();
	public void run() {
		System.out.println("Waiting for f() in BlockedMutex()");
		blocked.f();
		System.out.println("Broken out of blocked call");
	}
}

public class Interrupting2 {
	public static void main(String[] args) throws InterruptedException {
		Thread t = new Thread(new Blocked2());
		t.start();
		TimeUnit.SECONDS.sleep(1);
		System.out.println("Issuing t.interrupt()");
		t.interrupt();
	}
}/*output:
Waiting for f() in BlockedMutex()
Issuing t.interrupt()
Interrupted from lock acquisition in f()
Broken out of blocked call
*/

上面关于 IO 和 Synchronized 的例子只是最最简单的使用，其实这里我们只需要知道 IO 和 Synchronized 阻塞状态不可中断，但是通过使用新的技术，如 NIO 和 concurrent 提供的 ReentrantLock 就可以解决这个问题。所以，以后遇到阻塞和中断的问题，就可以知道大概的解决思路啦。

####5. 检查中断

这一小节看了3、4遍才算豁然开朗，真的是书读百遍，其义自现啊。下面就是书中很经典的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package concurrency;

import java.util.concurrent.TimeUnit;

class NeedsCleanup {
	private final int id;

	public NeedsCleanup(int ident) {
		id = ident;
		System.out.println("NeedsCleanup " + id);
	}

	public void cleanup() {
		System.out.println("Cleaning up " + id);
	}
}

// 模拟一个计算密集型的任务
class Blocked3 implements Runnable {
	private volatile double d = 0.0;

	public void run() {
		try {
			while (!Thread.interrupted()) {
				// Point1 在需要清理的资源后，需要立即跟上 try-catch-finally
				NeedsCleanup n1 = new NeedsCleanup(1);
				try {
					System.out.println("Sleeping");
					TimeUnit.SECONDS.sleep(1);

					// Point2 同上
					NeedsCleanup n2 = new NeedsCleanup(2);
					try {
						System.out.println("Calculating");
						for (int i = 1; i < 2500000; i++) {
							d = d + (Math.PI + Math.E) / d;
						}
						System.out.println("Finished time-consuming operation");
					} finally {
						n2.cleanup();
					}
				} finally {
					n1.cleanup();
				}
			}
			System.out.println("Exiting via while() test");
		} catch (InterruptedException e) {
			System.out.println("Exiting via InterruptedException");
		}
	}
}

// 通过传入不同的时间，来让 interrupt 发生在 Point1和 Point2的前后
// 当在 P1和 P2之间传入中断，会在 while 循环结束后达到 while 条件退出
// 当在 P1前面调用，会在视图调用阻塞(sleep()操作)或者在阻塞中(正在 sleep())通过 InterruptedException 退出阻塞
// 那么，紧接着 n1和n2的 try-catch-finally 就会正确的清理资源
public class IntererptingIdiom {
	public static void main(String[] args) throws NumberFormatException,
			InterruptedException {
		if (args.length != 1) {
			System.out.println("Usage: java InterruptingIdiom delay-in-mS");
			System.exit(1);
		}
		Thread t = new Thread(new Blocked3());
		t.start();
		TimeUnit.MILLISECONDS.sleep(new Integer(args[0]));
		t.interrupt();
	}
}

这个例子设计很简单，一个是阻塞的sleep()操作，一个是非阻塞的运算操作。我们在两个阶段中传入中断状态时，sleep()会通过 InterruptedException 从阻塞中中断，而运算操作只能在 while()条件检测中断后才能中断。NeedCleanup 类强调在由异常离开循环时，正确清理资源的必要性。

这个程序需要传入一个时间，然后在run()的不同运行点传入中断。多次试验后可以看到：

如果 interrupt(）在 P2后面调用，那么首先循环肯定要运行完，然后所有的本地对象将被销毁，最后循环会经由 while语句的顶部退出；
如果 interrupt()在 P1和 P2之间调用（while 之后，但是在阻塞操作 sleep()之前或者其过程中）被调用，那么这个任务就会在第一次视图调用阻塞操作之前，经由 InterruptedException退出。这种情况下，唯一创建出来的 n1会被紧跟其后的 try-catch-finally及时清理

根据上面的思路，我们可以得出一个结论：

被设计用来响应 interrput()的类必须建立一种策略，来确保它将保持一致的状态。这通常意味着所有需要清理的对象创建操作的后面，都必须紧跟 try-catch-finally子句，从而使得无论 run()循环如何退出，清理都会发生。【然后作者吐槽，要是 Java 有析构函数就好了。。。。析构操作直接在类中写，不用和业务代码耦合了】