《Java Concurrency in Practice》ch5 Building Blocks

《Java并行编程实战》ch5 基础构建模块 这章写的真不错，总结了3个有意思的问题。

1. 不使用信号量，实现生产者-消费者问题

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class PC {

public static void main(String[] args) {
BlockingQueue<Integer> q = new LinkedBlockingQueue<Integer>(3);
Producer p = new Producer(q);
Consumer c1 = new Consumer(q);
Consumer c2 = new Consumer(q);
new Thread(p).start();
new Thread(c1).start();
new Thread(c2).start();
}

}

class Producer implements Runnable {
private final BlockingQueue<Integer> queue;

public Producer(BlockingQueue<Integer> q) {
queue = q;
}

public void run() {
try {
while (true) {
System.out.println("size : " + queue.size());
System.out.println(">> put ");
queue.put(produce());
System.out.println("<< put ");
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}

Integer produce() {
int a = (int) (Math.random() * 1000);
System.out.println("Producer produced " + a);

//		try {
//			Thread.sleep(100);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
return a;
}
}

class Consumer implements Runnable {
private final BlockingQueue<Integer> queue;

public Consumer(BlockingQueue<Integer> q) {
queue = q;
}

public void run() {
try {
while (true) {
consume(queue.take());
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}

void consume(Integer x) {
try {
System.out.println("Consumer " + Thread.currentThread().getId()
+ " is consuming " + x.intValue());
Thread.sleep(x.intValue());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

运行结果：

size : 0
>> put
Producer produced 396
Consumer 10 is consuming 396
<< put
size : 0
>> put
Producer produced 236
<< put
size : 1
>> put
Producer produced 899
<< put
size : 2
>> put
Producer produced 555
<< put
size : 3
>> put
Producer produced 601
<< put
size : 3
>> put
Producer produced 609
Consumer 9 is consuming 236
Consumer 9 is consuming 899
<< put
size : 3
>> put
Producer produced 561
Consumer 10 is consuming 555
<< put
size : 3
>> put
Producer produced 377
Consumer 10 is consuming 601
<< put
size : 3
>> put
Producer produced 872
Consumer 9 is consuming 609
<< put
size : 3
>> put
Producer produced 818
Consumer 10 is consuming 561
<< put
size : 3
>> put
Producer produced 872
Consumer 9 is consuming 377
<< put
size : 3
>> put
Producer produced 522
<< put
size : 3
>> put
Producer produced 841
Consumer 10 is consuming 872
Consumer 9 is consuming 818
<< put
size : 3
>> put
Producer produced 540
Consumer 9 is consuming 872
<< put
size : 3
>> put
Producer produced 90
Consumer 10 is consuming 522
<< put
size : 3
>> put
Producer produced 576

从上面的结果可以看出，当BlockingQueue满了后，生产者在执行put时会被阻塞住，当消费者从队列里取走一个元素后，生产者的put才会成功返回。

2. 如何让一组线程同时开始？如何等待一组线程全部结束？

CountDownLatch!

3. 如何实现高效的缓存服务器？

ConcurrentHashMap + FutureTask