`

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

Java多线程工作J#thread 
阅读更多
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();
				}
			}
		}
	}

}
分享到：
| Java插入排序代码整理
评论
4 楼 maozj 2010-06-02  
mylazygirl 写道
private void executeLogin(final int taskID, int[] b)方法中那个switch case…… if(taskID > numTasks) 不行么

恩 完全可以的
3 楼 maozj 2010-06-02  
wfine 写道
用ExecutorService回简化线程池的管理~~~

呵呵 是的

升级版 改成那种
2 楼 wfine 2010-06-02  
用ExecutorService回简化线程池的管理~~~
1 楼 mylazygirl 2010-06-01  
private void executeLogin(final int taskID, int[] b)方法中那个switch case…… if(taskID > numTasks) 不行么
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java线程池学习--1

    NULL 博文链接：https://lhgyy00.iteye.com/blog/450628

    java技术学习-基于Java线程池技术实现Knock Knock游戏项目（包含服务端、客户端两部分）

    java技术学习——基于Java线程池技术实现Knock Knock游戏项目（包含服务端、客户端两部分） java技术学习——基于Java线程池技术实现Knock Knock游戏项目（包含服务端、客户端两部分） java技术学习——基于Java...

    java线程池使用后到底要关闭吗

    java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...

    基于Java线程池技术的数据爬虫设计与实现.pdf

    线程池技术是多线程编程中的一种重要技术，它是一种管理线程的容器。线程池中维护一定数量的活动线程，当有任务提交时，线程池就会分配一个线程来执行该任务。执行完毕后，线程并不会立即销毁，而是返回到线程池中，...

    java线程池封装j

    Java线程池是一种高效管理线程的技术，它允许开发者预定义一组线程，根据任务的需要灵活调度，而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能，减少了系统资源的消耗，特别是在高并发...

    Java并发编程：线程池的使用 - 平凡希 - 博客园1

    Java并发编程中的线程池是提高系统效率的关键工具，它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务，从而避免了每次任务执行完毕后销毁线程的开销。在Java中，线程池的核心实现是`java....

    自定义实现Java线程池2-完善异常处理和去除同步1

    在Java编程中，自定义线程池是一项常见的需求，它可以帮助我们更有效地管理和控制并发执行的任务。本文将讨论如何在自定义线程池中完善异常处理和去除同步，以提高效率和程序的健壮性。 首先，从提供的代码片段来看...

    线程-线程池-锁-集合-Map-队列.docx

    在Java中，使用`ExecutorService`和`ThreadPoolExecutor`来创建线程池，而不是直接使用`Executors`，因为`Executors`创建的线程池可能会导致资源耗尽的问题。 集合是Java中存储数据的主要工具，包括List、Set和Map...

    java线程池知识.ppt

    java线程池知识、

    JAVA线程池例子

    Java线程池是一种高效管理线程资源的技术，它允许开发者创建一组可重用的工作线程，从而避免频繁地创建和销毁线程带来的性能开销。线程池在Java中主要通过`java.util.concurrent`包中的`ExecutorService`接口及其...

    Java线程池与ThreadPoolExecutor.pdf

    Java线程池是Java并发编程中的重要组成部分，它允许开发者管理多个线程并有效地调度任务。线程池通过ThreadPoolExecutor类实现，这是一个高度可配置的工具，能够根据具体需求定制线程的创建、管理和销毁策略。 ...

    自定义实现Java线程池

    ### 自定义实现Java线程池 #### 一、概述 在深入探讨自定义Java线程池之前，我们先简要回顾一下线程池的基本概念及其重要性。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动...

    java线程池threadpool简单使用源码

    Java线程池（ThreadPool）是Java并发编程中的一个重要概念，它可以帮助我们有效地管理和控制并发执行的任务，从而提高系统的效率和稳定性。线程池通过复用已存在的线程，避免了频繁创建和销毁线程带来的开销，同时也...

    Java 线程池.pptx

    讲述了java线程池的优点，参数，6种线程池的使用场景，线程池用到的handler,线程任务的提交方式等等。

    Java 线程池.docx

    在Java中，通过使用线程池，我们可以预先创建一定数量的线程，这些线程在空闲时可以被复用，从而避免了每次创建新线程时的系统开销。此外，线程池还可以控制并发量，防止过多线程导致系统资源耗尽，从而提高系统的...

    在spring boot中使用java线程池ExecutorService的讲解

    在 Spring Boot 中使用 Java 线程池 ExecutorService 的讲解 Spring Boot 作为一个流行的 Java 框架，提供了许多便捷的功能来帮助开发者快速构建应用程序。其中之一就是使用 Java 线程池 ExecutorService 来管理...

    Java线程池技术详解

    线程池是Java并发编程中的一个重要概念，它是一种线程使用模式，旨在优化线程的管理和使用，提高系统资源的利用率。线程池的引入是为了应对频繁创建和销毁线程所带来的性能开销，因为创建和销毁线程都需要消耗内存...

    JAVA使用线程池查询大批量数据

    本文将深入探讨如何在Java中使用线程池来查询大量数据，以及这样做的好处和实现方法。 首先，理解线程池的概念至关重要。线程池是一种多线程处理形式，预先创建了若干个线程，当有任务需要执行时，会从线程池中取出...

    java线程池的源码分析.zip

    Java线程池是Java并发编程中的重要组成部分，它在多线程和高并发场景下扮演着关键角色。本文将深入探讨Java线程池的源码分析，并对比不同类型的线程池，以帮助开发者更好地理解和利用这一强大的工具。 首先，我们要...

    java线程池实例

    本实例将深入探讨如何在Java中使用线程池，以及其背后的原理和最佳实践。 首先，线程池的基本工作原理是接收`Runnable`或`Callable`任务，将其存储在队列中，并由池中的线程处理。线程池可以预先配置最大线程数、...

Magicbox
Global site tag (gtag.js) - Google Analytics