1. Single Thread Execution Pattern
1. 概念
该Pattern用来限制多个线程同时对share resource的访问只让一个线程访问，一般通过synchronzied或lock来完成。
2. demo
Gate类（ShareResource），多线程共同访问。
public class Gate {
private int counter = 0;
private String name = "Nobody";
private String address = "Nowhere";
public synchronized void pass(String name, String address) {
this.counter++;
this.name = name;
this.address = address;
check();
}
public synchronized String toString() {
return "No. " + counter + " name: " + name + ", address: " + address;
}
private void check() {
if (name.charAt(0) != address.charAt(0)) {
System.out.println("******BROKEN*******" + toString());
}
}
}
public class UserThread extends Thread {
private final Gate gate;
private final String myname;
private final String myaddress;
public UserThread(Gate gate, String myname, String myaddress) {
this.gate = gate;
this.myname = myname;
this.myaddress = myaddress;
}
public void run() {
System.out.println(this.myname + "Begin");
while (true) {
gate.pass(this.myname, myaddress);
}
}
}
public class Main {
public static void main(String[] args) {
Gate gate = new Gate();
new UserThread(gate, "Alice", "Alaska").start();
new UserThread(gate, "Bobby", "Brazil").start();
new UserThread(gate, "Chris", "Canada").start();
}
}
3. 注意事项
- 使用场景
当多个线程同时访问共享资源，并可能进行修改，而修改的结果会影响其他线程的运行结果时，就需要用该模式。
- 性能
一般来说，该模式会使程序性能降低的原因有两点。一是不管synchronzied或者lock，获取锁对象都需要耗费时间。二是当某线程获得锁对象进入临界区，其他的线程
都需要等待该线程释放锁对象，这个状况称之为冲突。当冲突发生时，线程等待的时间就会使整个程序的心跟那个下降。故应该尽可能的缩小临界区范围，以减少出现线程冲突
的机会， 可抑制性能的降低。
2. Immutable Pattern
1. 概念
在Immutable Pattern中，有着能够保证实例状态绝不会改变的类（immutable类）。因为访问这个实例时，可以省去使用共享互斥机制所会浪费的时间，故若能妥善运
用，将能提高程序的性能。String类，基本类型的封装类（Integer, Long等）就是一个immutable的类。
2. demo
Person类，final类型，不可变
public final class Person {
private final String name;
private final String address;
public Person(String name, String address) {
this.name = name;
this.address = address;
}
public String getName() {
return this.name;
}
public String getAddress() {
return this.address;
}
public String toString() {
return "[ Person: name =" + name + ", address = " + address + " ]";
}
}
public class PrintPersonThread extends Thread {
private Person person;
public PrintPersonThread(Person persion) {
this.person = person;
}
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + " prints "
+ person);
}
}
}Main测试
public class Main {
public static void main(String[] args){
Person alice = new Person("Alice", "Alaska");
new PrintPersonThread(alice).start();
new PrintPersonThread(alice).start();
new PrintPersonThread(alice).start();
}
}3. 注意事项
- 使用场景
1. 当实例产生后，状态不再变化
2. 实例需要共享，且访问很频繁
- 性能
因不用获取锁和减少了冲突，善于该模式能有效提升程序的性能。
3. Guarded Suppension Pattern
1. 概念
当线程执行某个操作时，发现条件并不满足，就要求要执行该操作的线程等待挂起。
2. demo
public class Request {
private String name;
public Request(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "[ Request " + name + " ]";
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： RequestQueue.java
* 类描述： 消息存储类
* </pre>
*/
public class RequestQueue {
final private LinkedList<Request> queue = new LinkedList<Request>();
public synchronized void putRequest(Request request) {//生产者生产消息后通知消费者消费
this.queue.addLast(request);
notifyAll();
}
public synchronized Request getRequest() {
while (this.queue.size() <= 0) {//如果执行条件不满足，则线程wait
try {
wait();
}catch (InterruptedException e) {
}
}
return queue.removeFirst();
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ServerThread.java
* 类描述：生产者线程，生成消息并存储到消息存储队列中
* </pre>
*/
public class ServerThread extends Thread {
private Random random;
private RequestQueue queue;
public ServerThread(RequestQueue queue, String name, long seed) {
super(name);
this.queue = queue;
random = new Random(seed);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
Request request = queue.getRequest();
System.out.println(Thread.currentThread().getName() + " handles " + request);
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ClientThread.java
* 类描述： 消费者线程，从消息存储队列中消费消息，若无消息消费，则等待。
* </pre>
*/
public class ClientThread extends Thread {
private Random random;
private RequestQueue requestQueue;
public ClientThread(RequestQueue requestQueue, String name, long seed) {
super(name);
this.requestQueue = requestQueue;
this.random = new Random(seed);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
Request request = new Request("No." + i);
System.out.println(Thread.currentThread().getName() + " requests " + request);
this.requestQueue.putRequest(request);
try {
Thread.sleep(this.random.nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}public class Main {
public static void main(String[] args) {
RequestQueue queue = new RequestQueue();
ServerThread serverThread = new ServerThread(queue, "ServerThread", 21563L);
ClientThread clientThread = new ClientThread(queue, "ClientThread", 24871L);
serverThread.start();
clientThread.start();
}
}3. 注意事项
- 使用场景
生产者消费者模式，异步执行的一种实现。
4. Balking Pattern
1. 概念
Balking Pattern与Guarded Suppension Pattern类似，区别在于当线程执行某一操作发现条件不满足时，是立即返回，中断执行，而不是等待条件满足。
2. demo
public class Data {
private final String filename;
private String content;
private boolean changed;
public Data(String filename, String content) {
this.filename = filename;
this.content = content;
this.changed = true;
}
/**
* 修改文件内容
* @param content
*/
public synchronized void change(String content) {
this.content = content;
this.changed = true;
}
/**
* 保存修改后的数据,保存到硬盘上
*/
public synchronized void save() {
while (!this.changed) {//如果发现文件没有被修改，则不做保存动作
return;
}
doSave();
this.changed = false;
}
private void doSave() {
System.out.println(Thread.currentThread().getName()
+ "calls doSave, content = " + this.content);
File file = new File(filename);
FileWriter writer = null;
try {
writer = new FileWriter(file, true);
writer.write(this.content);
} catch (IOException e) {
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ChangerThread.java
* 类描述： 改变文件内容线程
* </pre>
*/
public class ChangerThread extends Thread {
private Data data;
private Random random = new Random();
public ChangerThread(String name, Data data) {
super(name);
this.data = data;
}
@Override
public void run() {
int i = 0;
while (true) {
i++;
String content = "No." + i;
this.data.change(content);
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
this.data.save();
}
}
}/**
* <pre>
* 项目名： ThreadPattern
* 类名： SaverThread.java
* 类描述： 保存文件线程
* </pre>
*/
public class SaverThread extends Thread {
private Data data;
private Random random = new Random();
public SaverThread(String name, Data data) {
super(name);
this.data = data;
}
@Override
public void run() {
while (true) {
this.data.save();
try {
Thread.sleep(this.random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}/**
* <pre>
* 项目名： ThreadPattern
* 类名： Main.java
* 类描述： 测试
* </pre>
*/
public class Main {
public static void main(String[] args) {
Data data = new Data("data.txt", "(empty)");
new SaverThread("SaverThread", data).start();
new ChangerThread("ChangerThread", data).start();
}
}3. 注意事项
- 使用场景
1. 不需要可以去执行的时候，如在上面的demo中，如果文件内容没有被修改，则不需要执行保存动作， 可提高程序性能。
2. 不想等待条件满足时，可提高程序的响应时间。
3. 某操作只需要执行一次时，如初始化。
5. Producer - Customer Pattern
1. 概念
Producer - Customer Pattern（生产者消费者模式），生产者生产消息，消费者消费消息，二者处理消息的速度可能不一致，那么需要一个缓存区来存放消息。
2. demo
/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Data.java
* 类描述：消息
* </pre>
*/
public class Data {
private String name;
public Data(String name) {
this.name = name;
}
@Override
public String toString() {
return "[ Data name = " + this.name + " ]";
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Channel.java
* 类描述： 消息缓冲区，默认大小100，可以通过构造函数定制channel的大小。channel为FIFO模型
* </pre>
*/
public class Channel {
private final LinkedList<Data> buffer = new LinkedList<Data>();
private int bufferSize = 100;
public Channel() {
super();
}
public Channel(int channelSize) {
this.bufferSize = channelSize;
}
/**
* put数据到channel中，当channel的buffer大小大于或等于指定大小时，方法将进行等待
*
* @param data
*/
public synchronized void put(Data data) {
while (buffer.size() >= this.bufferSize) {
try {
wait();
} catch (InterruptedException e) {
}
}
this.buffer.addLast(data);
System.out.println(Thread.currentThread().getName() + " put data "+ data);
notifyAll();
}
/**
* 从channel中获取数据，当channel中没有数据时，进行等待
*
* @return
*/
public synchronized Data take() {
while (this.buffer.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
}
}
Data data = this.buffer.removeFirst();
System.out.println(Thread.currentThread().getName() + " take date " + data);
notifyAll();
return data;
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ProducerThread.java
* 类描述： 生产者线程，生成消息并放入到消息缓冲区中
* </pre>
*/
public class ProducerThread extends Thread {
private Channel channel;
private Random random = new Random();
private static int dataNo = 0;
public ProducerThread(String name, Channel channel) {
super(name);
this.channel = channel;
}
@Override
public void run() {
while (true) {
Data data = new Data("No." + nextDataNo());
this.channel.put(data);
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
public static synchronized int nextDataNo() {
return ++dataNo;
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ComsumerThread.java
* 类描述：消费者线程，从消息缓存区Channel消费消息
* </pre>
*/
public class ComsumerThread extends Thread {
private Channel channel;
private Random random = new Random();
public ComsumerThread(String name, Channel channel) {
super(name);
this.channel = channel;
}
@Override
public void run() {
while (true) {
this.channel.take();
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}public class MainThread {
public static void main(String[] args) {
int channelSize = 1000;
Channel channel = new Channel(channelSize);
ProducerThread producer1 = new ProducerThread("Producer1", channel);
ProducerThread producer2 = new ProducerThread("Producer2", channel);
ComsumerThread comsumer1 = new ComsumerThread("Comsumer1", channel);
ComsumerThread comsumer2 = new ComsumerThread("Comsumer2", channel);
ComsumerThread comsumer3 = new ComsumerThread("Comsumer3", channel);
producer1.start();
producer2.start();
comsumer1.start();
comsumer2.start();
comsumer3.start();
}
}3. 注意事项
- 使用场景
经常用作消息中心，异步消费消息，
6. Read - Write Lock Pattern
1. 概念
Reade-Write Lock Pattern将读取与写入分开来处理。在读取数据之前，必须获取用来读取的锁定。而要写入的时候，则必须获取用来写入的锁定。因为在读取的时候，实
例的状态不会改变，所以，就算有多个线程在同时读取也没有关系。但是，有线程在读取的时候，不能做写入的操作。写入的时候，实例的状态会该别，于是，在有一个线程写
入的时候，其他线程就不可以进行读取或者写入。
一般来说，进行共享互斥会使程序性能变差，但将写入的共享互斥与读取的共享分开来思考，就可以提升程序的性能。
2. demo
/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ReadWriteLock.java
* 类描述：读写锁
* </pre>
*/
public class ReadWriteLock {
/**
* 正在读取的线程数
*/
private int readingThreadsNumber;
/**
* 正在写入的线程数（最多为1）
*/
private int writingThreadsNumber;
/**
* 等待写入的线程数
*/
private int waitingWriteThreadsNumber;
/**
* 是否优先写入，true：优先写入；false：优先读取
*/
private boolean preferWriter = true;
public synchronized void readLock() throws InterruptedException {
// 如果有线程正在写入或者优先写入时，有线程正在等待写入，读取线程则等待
while (this.writingThreadsNumber > 0
|| (this.preferWriter && this.waitingWriteThreadsNumber > 0)) {
wait();
}
this.readingThreadsNumber++;
}
public synchronized void readUnlock() throws InterruptedException {
this.readingThreadsNumber--;
this.preferWriter = true;
notifyAll();
}
public synchronized void writeLock() throws InterruptedException {
this.waitingWriteThreadsNumber++;
// 如果有线程正在写入或者正在读取，当前写入线程等待
try {
while (this.writingThreadsNumber > 0
|| this.readingThreadsNumber > 0) {
wait();
}
} finally {
this.waitingWriteThreadsNumber--;
}
this.writingThreadsNumber++;
}
public synchronized void writeUnlock() throws InterruptedException {
this.writingThreadsNumber--;
this.preferWriter = false;
notifyAll();
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Data.java
* 类描述：数据存储对象
* </pre>
*/
public class Data {
private char[] buffer;
private ReadWriteLock readWriteLock = new ReadWriteLock();
public Data(int size) {
this.buffer = new char[size];
for (int i = 0; i < size; i++) {
this.buffer[i] = '*';
}
}
public char[] read() throws InterruptedException {
try {
readWriteLock.readLock();
return doRead();
} finally {
readWriteLock.readUnlock();
}
}
public void write(char c) throws InterruptedException {
try {
readWriteLock.writeLock();
doWrite(c);
} finally {
readWriteLock.writeUnlock();
}
}
private char[] doRead() {
char[] newChars = new char[buffer.length];
System.arraycopy(this.buffer, 0, newChars, 0, this.buffer.length);
slowly();
return newChars;
}
private void doWrite(char c) {
for (int i = 0; i < this.buffer.length; i++) {
this.buffer[i] = c;
slowly();
}
}
private void slowly() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ReaderThread.java
* 类描述：读线程
* </pre>
*/
public class ReaderThread extends Thread {
private static final Random random = new Random();
private final Data data;
public ReaderThread(Data data) {
this.data = data;
}
@Override
public void run() {
while (true) {
try {
char[] c = data.read();
System.out.println(Thread.currentThread().getName() + "reads " + String.valueOf(c));
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： WriterThread.java
* 类描述：写线程
* </pre>
*/
public class WriterThread extends Thread {
private static final Random random = new Random();
private final Data data;
private final String filler;
private int index = 0;
public WriterThread(Data data, String filler) {
this.data = data;
this.filler = filler;
}
@Override
public void run() {
while (true) {
char c = nextChar();
try {
data.write(c);
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
private char nextChar() {
char c = filler.charAt(index);
index++;
if (index > filler.length()) {
index = 0;
}
return c;
}
}public class MainThread {
public static void main(String[] args) {
int bufferSize = 10;
Data data = new Data(bufferSize);
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
new ReaderThread(data).start();
String filler1 = "abcdefghjklmnopqrstuvwxyz";
String filler2 = "ABCDEFGHJKLMNOPQRSTUVWXYZ";
new WriterThread(data, filler1).start();
new WriterThread(data, filler2).start();
}
}3. 注意事项
- 使用场景
1. 利用同时读不会冲突的特性，提高程序的性能
2. 适合读取操作十分频繁
3. 适合读取比写入次数频繁
7. Thread-Per-Message Pattern
1. 概念
Thread-Per-Message Pattern指每个消息一个线程，即对于每个命令或请求，分配一个线程去执行。
2. demo
/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Helper.java
* 类描述： 消息执行线程
* </pre>
*/
public class Helper {
public void handle(int count, char c) {
System.out.println("handle(" + count + ", " + c + ") BEGIN");
for (int i = 0; i < count; i++) {
System.out.print(c);
slowly();
}
System.out.println("");
System.out.println("handle( " + count + ", " + c + ") END");
}
private void slowly() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
}
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Host.java
* 类描述： 消息处理线程（委托给另一个线程去处理）
* </pre>
*/
public class Host {
private final Helper helper = new Helper();
public void request(final int count, final char c) {
System.out.println("reqeust (" + count + ", " + c + ") BEGIN");
new Thread() {//将消息委托给另外一个线程去处理
@Override
public void run() {
helper.handle(count, c);
}
}.start();
System.out.println("reqeust (" + count + ", " + c + ") END");
}
}public class MainThread {
public static void main(String[] args) {
System.out.println("main Begin");
Host host = new Host();
host.request(10, 'a');
host.request(20, 'b');
host.request(30, 'c');
System.out.println("main End");
}
}3. 注意事项
- 使用场景
1. 提高相应性， 降低延迟时间
2. 适合在操作顺序无所谓时使用
3. 不需要返回之的时候
4. 应用在服务器的制作，将服务端接受消息的线程和处理消息的线程分开
8. Worker Thread Pattern
1. 概念
Worker Threade Pattern指工作线程会依次抓意见工作来处理，当没有工作可作时，工作线程会停下来等待新的工作过来。Worker Thread 也被称为是Backgound
Thread（背景线程）， 另外，也有人把管理工作线程的地方，称为 Thread Pool （线程池）。
2. demo
/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Request.java
* 类描述： 消息对象
* </pre>
*/
public class Request {
private final String name;
private final int number;
private final static Random random = new Random();
public Request(String name, int number) {
this.name = name;
this.number = number;
}
public void request() {
System.out.println(Thread.currentThread().getName() + " " + toString());
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
@Override
public String toString() {
return "[ Reqeust name = " + name + ", number = " + number + " ]";
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： Channel.java
* 类描述： 消息存储容器
* </pre>
*/
public class Channel {
private final LinkedList<Request> buffers = new LinkedList<Request>();
private static final int bufferSize = 100;
public synchronized void put(Request request) throws InterruptedException {
while (this.buffers.size() >= bufferSize) {
wait();
}
this.buffers.addLast(request);
notifyAll();
}
public synchronized Request take() throws InterruptedException {
while (this.buffers.size() == 0) {
wait();
}
Request request = this.buffers.removeFirst();
notifyAll();
return request;
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： ProducerThread.java
* 类描述： 生产者线程，将生产消息并将消息放到消息容器中
* </pre>
*/
public class ProducerThread extends Thread {
private final Channel channel;
private final static Random random = new Random();
public ProducerThread(String name, Channel channel) {
super(name);
this.channel = channel;
}
@Override
public void run() {
int i = 0;
while (true) {
Request request = new Request(getName(), ++i);
try {
this.channel.put(request);
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}/**
*
* <pre>
* 项目名： ThreadPattern
* 类名： WorkerThread.java
* 类描述：工作线程，从消息存储器中拿到消息处理， 没有则等待
* </pre>
*/
public class WorkerThread extends Thread {
private Channel channel;
public WorkerThread(String name, Channel channel) {
super(name);
this.channel = channel;
}
@Override
public void run() {
while (true) {
try {
Request request = this.channel.take();
request.request();
} catch (InterruptedException e) {
}
}
}
}/**
* <pre>
* 项目名： ThreadPattern
* 类名： WorkerTheradPool.java
* 类描述： 工作线程池
* </pre>
*/
public class WorkerTheradPool {
private WorkerThread[] threadPool;
public WorkerTheradPool(int threads, Channel channel) {
this.threadPool = new WorkerThread[threads];//定义一个工作线程组（线程池）
for (int i = 0; i < threads; i++) {
threadPool[i] = new WorkerThread("WorkerThread-" + (i + 1), channel);
}
}
public void startWorkers() {
for (int i = 0; i < this.threadPool.length; i++) {
threadPool[i].start();
}
}
}public class Main {
public static void main(String[] args) {
int threads = 5;
Channel channel = new Channel();
WorkerTheradPool pool = new WorkerTheradPool(threads, channel);
new ProducerThread("Alice", channel).start();
new ProducerThread("Bobby", channel).start();
new ProducerThread("Chris", channel).start();
pool.startWorkers();
}
}3. 注意事项
- 使用场景
1. 启动线程是个很繁杂的工作，可以先把线程创建好，用的时候再直接拿来用。
2. 控制承载量（即可以提供服务的线程数量），当任务繁重是可以扩大工作者线程数量，反之，可以减少。
9. Future Pattern
1. 概念
Futuren Pattern是指获取Futuren的线程，会在事后再去获取执行的结果。就好像拿提货单去领取蛋糕一样。如果已经有执行结果了， 就可以马上拿到数据；如果执行结果
还没有好，则继续等待执行结果出现为止。
2. demo
public interface Data {
public String getContent();
}public class FutureData implements Data {
private RealData realData;
private boolean ready = false;
public synchronized void setRealData(RealData realData) {
if (ready) {
return;
}
this.realData = realData;
this.ready = true;
notifyAll();
}
@Override
public synchronized String getContent() {
while (!ready) {//如果结果还没处理好，则等待
try {
wait();
} catch (InterruptedException e) {
}
}
return this.realData.getContent();
}
}public class RealData implements Data {
private String content;
public RealData(int count, char c) {
System.out.println("making RealData(" + count + ", " + c + ") Begin.");
//处理获取结果
char[] buffer = new char[count];
for (int i = 0; i < count; i++) {
buffer[i] = c;
slowly();
}
this.content = String.valueOf(buffer);
System.out.println("making RealData(" + count + ", " + c + ") End.");
}
@Override
public String getContent() {
return this.content;
}
private void slowly() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}public class Host {
public Data handle(final int count, final char c) {
System.out.println("handle ( " + count + ", " + c + ") Begin.");
final FutureData futureData = new FutureData();//创建Future对象
new Thread() {//将处理消息获取消息的工作交个另外一个线程去处理，参考Thread Per Message Pattern
@Override
public void run() {
RealData realData = new RealData(count, c);
futureData.setRealData(realData);
}
}.start();
System.out.println("handle ( " + count + ", " + c + ") End.");
return futureData;
}
}public class Main {
public static void main(String[] args) {
System.out.println("main Begin.");
Host host = new Host();
Data data1 = host.handle(10, 'a');
Data data2 = host.handle(20, 'b');
Data data3 = host.handle(30, 'c');
System.out.println("main other job Begin.");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("main other job End.");
System.out.println("data1 = " + data1.getContent());
System.out.println("data2 = " + data2.getContent());
System.out.println("data3 = " + data3.getContent());
System.out.println("main End.");
}
}3. 注意事项
- 使用场景
将任务交由另外一个线程去异步处理，自己能继续做自己的工作，即响应性不会降低，并且在工作线程处理完之后，还能获取处理结果。
10. Two-Phase Termination Pattern
1. 概念
我们将线程进行平常的处理的状态称为【作业中】， 当希望结束这个线程时，则送出【终止请求】。 接着这个线程，并不会马上结束， 而会开始处理必要的刷新工作。这
个状态称为【终止处理中】。 从【作业中】改变为【终止处理中】是第一个阶段。【终止处理中】的状态时，不会进行平常的操作，虽然线程还在运行，但是进行的是终止处
理。知道终止处理结束后，才真正结束线程。【终止处理中】的操作结束，是第二阶段。
可用来优雅的终止线程，一是安全的终止（安全性）， 二是一定会进行终止处理（生命性）， 三是在送出终止请求后，尽快的处理（响应性）。
2. demo
public class CountupThread extends Thread {
private boolean isShutdown = false;
private int count = 0;
@Override
public void run() {
try {
while (!isShutdown) {
doWork();
}
} catch (InterruptedException e) {
} finally {
doShutdown();
}
}
public void shutdownReqeust() {
this.isShutdown = true;//将shutDown标识设为true
interrupt();//仅置shutdown标识不正确，因为此时线程可能正在sleep或者wait，这样虽然sleep结束后，再来停止线程，但这样响应性就差饿了点。
}
private void doShutdown() {
System.out.println("doShutdown: current count is " + this.count);
}
private void doWork() throws InterruptedException {
System.out.println("curren count is " + ++count);
Thread.sleep(500);
}
}public class MainThread {
public static void main(String[] args) {
System.out.println("main Begin.");
CountupThread countupThread = new CountupThread();
countupThread.start();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
System.out.println("main : shutdown request.");
countupThread.shutdownReqeust();
System.out.println("main : join");
// 等待线程结束
try {
countupThread.join();
} catch (InterruptedException e) {
}
System.out.println("main End.");
}
}3. 注意事项
- 使用场景
1. 不可以使用Thread类的stop方法，stop会强制停止线程，就肯能丧失安全性，因为说不定线程刚好在做临界区。
2. 进行繁重的处理前，先检查终止请求，这样一来，可使得程序的响应性提高。
11. Thread-Specific Storage Pattern
1. 概念
Thread-Specific Storage Pattern就是线程独有的存储库，针对每个线程提供的内存空间，独立于线程之外。ThreadLocal的实例可以想象成一种集合框架，该类的实例只
有一个，实现是用Map<Key, Value>， Key为当前线程的id，Value为设置的值。
2. demo
public class Log {
//存储各个线程的Log日志，ThreadLocal<T>, 实现是一个map, key为当前线程id，value为T
private static final ThreadLocal<TSLog> tsLogCollection = new ThreadLocal<TSLog>();
public static void println(String s) {
getTSLog().printWrite(s);
}
public static void close() {
getTSLog().close();
}
private static TSLog getTSLog() {
TSLog tsLog = tsLogCollection.get();
// 如果线程时第一次调用，新建立新文件并注册log
if (tsLog == null) {
tsLog = new TSLog(Thread.currentThread().getName() + "-log.txt");
tsLogCollection.set(tsLog);
}
return tsLog;
}
}public class TSLog {
private PrintWriter writer;
public TSLog(String filename) {
try {
this.writer = new PrintWriter(filename);
} catch (FileNotFoundException e) {
}
}
public void printWrite(String s) {
writer.println(s);
}
public void close() {
writer.println("===========End of log===========");
writer.close();
}
}public class ClientThread extends Thread {
public ClientThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println(getName() + " Begin.");
for (int i = 0; i < 10; i++) {
Log.println("i = " + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
Log.close();
System.out.println(getName() + " End.");
}
}public class MainThread {
public static void main(String[] args) {
new ClientThread("Alice").start();
new ClientThread("Bobby").start();
new ClientThread("Chris").start();
}
}3. 注意事项
- 使用场景
1. 存放线程特有信息的地方
2. 线程安全的另种实现