单线程处置多任务处理方式

单线程处理多任务处理方式
缘由：
    在实际的应用中可能会出现这样一种尴尬：只有一个工作线程（这里叫单线程吧）处理大量的信息。而这些信息由线程池中的执行线程提供而来，起先想用线程同步的机制来实现，但这样子会出现了一些弊端：线程池中的线程会被卡住，直到这个单线程空闲才可以和这些线程池中的线程同步处理，这有违反当初设计这一线程池的目的。
   
  工作内容：
    1端信息输入
    2端信息输入        提取信息                                           处理结果
    3端信息输入 ———————— 用线程池处理 ———————— 交由单线程处理（只能有一个实例）
    ...
    n端信息输入

于是在单线程里面实现信息缓存机制。

单线程类
MakeWork.java

package work;

import java.util.ArrayList;
import java.util.List;

/**
 * 单线程 1、设置工作内容 2、自我唤醒功能 3、线程关闭
 */
public class MakeWork extends Thread
{
	private boolean shutdown = false;
	// 缓存列表
	private List<String> list = new ArrayList<String>();

	public void setMessage(String message)
	{
		synchronized (this)
		{
			list.add(message);
			notify();
		}
	}

	public void run()
	{
		while (!shutdown)
		{
			synchronized (this)
			{
				while (list.size() > 0)
				{
					String message = list.remove(0);
					System.out.println("message: " + message);
				}
			}
			try
			{
				wait();
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}

	}

	public void close()
	{
		synchronized (this)
		{
			this.shutdown = true;
			this.notify();
		}
	}
}

Work.java

package work;

/**
 * 虚拟线程池线程:将处理后返回的结果提交到单例线程
 */
public class Work
{
	// 单线程对象
	private MakeWork makeWork;

	public Work(MakeWork makeWork)
	{
		this.makeWork = makeWork;
	}

	// 将处理后返回的结果提交到单例线程
	public void work(String message)
	{
		makeWork.setMessage(message);
	}
}

测试类：
Test.java

package test;

import java.util.Random;

import work.MakeWork;
import work.Work;

public class Test
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		MakeWork makeWork = new MakeWork();
		makeWork.start();
// 虚拟1000个线程同时操作
		for (int i = 0; i < 1000; i++)
		{
			Work workThread = new Work(makeWork);
			workThread.work("do: " + i);
		}
	}

}

结果：
message: do: 0
message: do: 1
message: do: 2
message: do: 3
message: do: 4
message: do: 5
    .
    .
    .
    .