用Java线程池技术模拟 - 容器中的最大值输出及排序输出

1. 输出结果：

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

Task1 start...
Task1 输出容器1最大值: 97
Task2 start...
Task2 输出容器2最大值: 98
Task0 start...
Task3 start...
Task3 输出容器3最大值: 99
Task4 start...
Task4 输出容器4最大值: 98
Task0 输出容器0最大值: 93
Task2 end...
Task5 start...
Task5 输出容器5最大值: 97
Task0 end...
Task6 start...
Task6 输出容器6最大值: 99
Task4 end...
Task7 start...
Task7 输出容器7最大值: 97
Task1 end...
Task8 start...
Task8 输出容器8最大值: 94
Task3 end...
Task9 start...
Task9 输出容器9最大值: 94
Task5 end...
Task10 start...
Task10 输出容器10最大值: 85
Task9 end...
Task11 start...
Task11 输出容器11最大值: 98
Task6 end...
Task12 start...
Task12 输出容器12最大值: 55
Task7 end...
Task8 end...
Task13 start...
Task14 start...
Task13 输出容器13最大值: 96
Task14 输出容器14最大值: 97
Task10 end...
Task11 end...
Task14 end...
Task13 end...
Task12 end...

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


2. Java代码：

package boke.thread2;

import java.util.LinkedList;

/**
 * 线程池多任务模拟
 * 
 * @since jdk1.5及其以上
 * @author 毛正吉
 * @version 1.0
 * @date 2010.05.24
 * 
 */
public class ThreadPool extends ThreadGroup {
	/**
	 * 主函数
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// 任务的数目
		int numTasks = 15;

		// 线程池中的线程数目
		int poolSize = 5;

		// 创建线程池
		ThreadPool threadPool = new ThreadPool(poolSize);

		// 随机创建数组大小和索引值
		int[][] a = new int[numTasks][];
		for (int i = 0; i < a.length; i++) {
			a[i] = new int[(int) (Math.random() * 50) + 1];
			for (int j = 0; j < a[i].length; j++) {
				a[i][j] = (int) (Math.random() * 100);
			}
		}

		// 输出原始数组
		System.out.println("排序前的数组：");
		for (int i = 0; i < a.length; i++) {
			System.out.print("容器" + i + ": ");
			for (int j = 0; j < a[i].length; j++) {
				System.out.print(a[i][j] + " ");
			}
			System.out.println("");
		}
		System.out.println("");

		// 运行任务
		for (int i = 0; i < numTasks; i++) {
			threadPool.execute(createTask(i, a[i]));
		}
		threadPool.join();
		System.out.println("");

		// 输出排序后的数组
		System.out.println("排序后的数组：");
		for (int i = 0; i < a.length; i++) {
			System.out.print("容器" + i + ": ");
			for (int j = 0; j < a[i].length; j++) {
				System.out.print(a[i][j] + " ");
			}
			System.out.println("");
		}
		System.out.println("");

	}

	/**
	 * 创建任务
	 * 
	 * @param taskID
	 * @param b
	 * @return
	 */
	private static Runnable createTask(final int taskID, final int[] b) {
		return new Runnable() {
			public void run() {
				System.out.println("Task" + taskID + " start...");

				// 执行业务逻辑
				executeLogin(taskID, b);

				// 线程睡眠, 给其他线程执行的机会
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					System.out.println("Task" + taskID + ":end");
				}
				System.out.println("Task" + taskID + " end...");
			}

			/**
			 * 执行业务逻辑 - 输出容器b中的最大值
			 * 
			 * @param taskID
			 * @param b
			 */
			private void executeLogin(final int taskID, int[] b) {
				switch (taskID) {
				case 0:
					System.out.println("Task" + 0 + " 输出容器0最大值: " + getMax(b)); // 输出最大值
					insertSort(b); // 插入排序
					break;
				case 1:
					System.out.println("Task" + 1 + " 输出容器1最大值: " + getMax(b));
					insertSort(b);
					break;
				case 2:
					System.out.println("Task" + 2 + " 输出容器2最大值: " + getMax(b));
					insertSort(b);
					break;
				case 3:
					System.out.println("Task" + 3 + " 输出容器3最大值: " + getMax(b));
					insertSort(b);
					break;
				case 4:
					System.out.println("Task" + 4 + " 输出容器4最大值: " + getMax(b));
					insertSort(b);
					break;
				case 5:
					System.out.println("Task" + 5 + " 输出容器5最大值: " + getMax(b));
					insertSort(b);
					break;
				case 6:
					System.out.println("Task" + 6 + " 输出容器6最大值: " + getMax(b));
					insertSort(b);
					break;
				case 7:
					System.out.println("Task" + 7 + " 输出容器7最大值: " + getMax(b));
					insertSort(b);
					break;
				case 8:
					System.out.println("Task" + 8 + " 输出容器8最大值: " + getMax(b));
					insertSort(b);
					break;
				case 9:
					System.out.println("Task" + 9 + " 输出容器9最大值: " + getMax(b));
					break;
				case 10:
					System.out
							.println("Task" + 10 + " 输出容器10最大值: " + getMax(b));
					insertSort(b);
					break;
				case 11:
					System.out
							.println("Task" + 11 + " 输出容器11最大值: " + getMax(b));
					insertSort(b);
					break;
				case 12:
					System.out
							.println("Task" + 12 + " 输出容器12最大值: " + getMax(b));
					insertSort(b);
					break;
				case 13:
					System.out
							.println("Task" + 13 + " 输出容器13最大值: " + getMax(b));
					insertSort(b);
					break;
				case 14:
					System.out
							.println("Task" + 14 + " 输出容器14最大值: " + getMax(b));
					insertSort(b);
					break;
				default:
					System.out.println("no executed task...");

				}
			}

			/**
			 * 求容器a中的最大值
			 * 
			 * @param a
			 * @return
			 */
			public int getMax(int[] a) {
				int max = a[0];

				for (int i = 1; i < a.length; i++) {
					if (a[i] > max) {
						max = a[i];
					}
				}

				return max;
			}

			/**
			 * 插入排序
			 * 
			 * @param a
			 */
			public void insertSort(int[] a) {
				int out, in;

				for (out = 1; out < a.length; out++) {
					int temp = a[out];
					in = out;

					while (in > 0 && a[in - 1] >= temp) {
						a[in] = a[in - 1];
						--in;
					}
					a[in] = temp;
				}
			}
		};
	}

	// 线程池是否关闭
	private boolean isClosed = false;
	// 表示工作队列
	private LinkedList<Runnable> workQueue;
	// 表示线程池ID
	private static int threadPoolID;
	// 表示工作线程ID
	private int threadID;

	/**
	 * 构造方法
	 * 
	 * @param poolSize
	 */
	public ThreadPool(int poolSize) {
		super("ThreadPool-" + (threadPoolID++));
		this.setDaemon(true);
		this.workQueue = new LinkedList<Runnable>();
		for (int i = 0; i < poolSize; i++) {
			// 创建并启动工作线程
			new WorkThread().start();
		}
	}

	/**
	 * 向工作队列中加入一个任务，由工作线程去执行该任务
	 * 
	 * @param task
	 */
	public synchronized void execute(Runnable task) {
		// 线程池被关闭
		if (isClosed) {
			throw new IllegalStateException();
		}
		if (task != null) {
			workQueue.add(task);
			// 唤醒正在getTask()方法中等待任务的工作线程
			notify();
		}
	}

	/**
	 * 从工作队列中取出一个任务
	 * 
	 * @return
	 * @throws InterruptedException
	 */
	protected synchronized Runnable getTask() throws InterruptedException {
		while (workQueue.size() == 0) {
			if (isClosed)
				return null;
			wait();
		}
		return workQueue.removeFirst();
	}

	/**
	 * 关闭线程池
	 */
	public synchronized void close() {
		if (!isClosed) {
			isClosed = true;
			// 清空工作队列
			workQueue.clear();
			// 中断所有的工作线程
			interrupt();
		}
	}

	/**
	 * 等待工作线程把所有任务执行完
	 */
	public void join() {
		synchronized (this) {
			isClosed = true;
			notifyAll();
		}

		Thread[] threads = new Thread[activeCount()];
		// 获得线程组中当前所有活着的工作线程
		int count = this.enumerate(threads);
		// 等待所有工作线程运行结束
		for (int i = 0; i < count; i++) {
			try {
				// 等待工作线程运行结束
				threads[i].join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 内部类：工作线程
	 * 
	 * @author 毛正吉
	 * 
	 */
	private class WorkThread extends Thread {
		public WorkThread() {
			// 加入到当前ThreadPool线程组中
			super(ThreadPool.this, "WorkThread-" + (threadID++));
		}

		public void run() {
			while (!isInterrupted()) {
				Runnable task = null;
				try {
					// 取出任务
					task = getTask();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				if (task == null) {
					return;
				}

				try {
					task.run();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

}