多线程（六）实战--手写简单的线程池

1.什么是线程池？为什么用使用它

1.降低资源的消耗，在之前做elasticsearch高级客户端的开发的项目中，每一次创建与elasticsearch的连接都会花费不少的时间，大约是1-2秒左右，这样的话，使用elastcisearch这样的分布式搜索服务器就没有必要了。所以可以使用线程池来对连接进行优化，如能把创建好的连接保存在线程池里，每一次需要调用的时候从线程池中取出连接，可以大幅度的节约时间，提高资源利用率。

2.实现一个简单的线程池的demo案例。

package main;

import java.util.Arrays;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MyThreadPool2 {
	// 线程池中线程个数为5
	private static int WORK_NUM = 5;
	// 队列中的队列任务为100
	private static int TASK_COUNT = 100;

	// 工作线程组
	private WorkThread[] workThreads;

	// 任务队列
	private BlockingQueue<Runnable> taskQueue = null;
	private final int worker_num;// 用户构造这个线程池的时候希望启用的线程组

	// 根据个数创建默认的线程池
	public MyThreadPool2() {
		this(WORK_NUM, TASK_COUNT);
	}

	@Override
	public String toString() {
		return "MyThreadPool2 [workThreads=" + Arrays.toString(workThreads) + ", taskQueue=" + taskQueue
				+ ", worker_num=" + worker_num + "]";
	}

	public MyThreadPool2(int worker_num, int taskCount) {
		if (WORK_NUM <= 0) {
			worker_num = WORK_NUM;
		}
		if (taskCount <= 0) {
			taskCount = TASK_COUNT;
		}
		this.worker_num = worker_num;
		taskQueue = new ArrayBlockingQueue<>(taskCount);

		workThreads = new WorkThread[worker_num];
		for (int i = 0; i < worker_num; i++) {
			workThreads[i]=new WorkThread();
	    	workThreads[i].stopWorker();
			workThreads[i].start();
		}

	}

	// 执行任务，把任务加入队列中，什么时候执行由线程池来决定
	public void execute(Runnable task) {
		try {
			taskQueue.put(task);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void destory()
	{
		System.out.println("ready close pool");
		for (int i=0;i<worker_num;i++)
		{
			workThreads[i].stopWorker();
			workThreads[i]=null;
		}
		taskQueue.clear();
		
	}
	

	/**
	 * 内部类，工作线程
	 * 
	 * @author xuyuanfeng
	 *
	 */
	private class WorkThread extends Thread {

		public WorkThread() {
			// TODO Auto-generated constructor stub
		}

		@Override
		public void run() {
			Runnable r = null;
			// 当前线程有没有被终止
			while (!isInterrupted()) {
				try {
					r = taskQueue.take();
					if (r != null) {
						System.out.println(getId() + " ready exec:" + r);
						r.run();
					}
					r = null;
				} catch (InterruptedException e) {
					e.printStackTrace();
				} // 拿到任务

			}
		}

		//中断线程
		public void stopWorker() {
			interrupt();
		}
	}

}

package main;

import java.util.Random;

public class Main {
	public static void main(String[] args) throws InterruptedException {

		MyThreadPool2 t = new MyThreadPool2(3, 0);
		t.execute(new MyThread("testA"));
		t.execute(new MyThread("testB"));
		t.execute(new MyThread("testC"));
		t.execute(new MyThread("testD"));
		t.execute(new MyThread("testE"));
		Thread.sleep(10000);
		t.destory();
		System.out.println(t.toString());

	}

	static class MyThread implements Runnable {
		private String name;
		private Random r = new Random();

		public MyThread(String name) {
			this.name = name;
		}

		public String getName() {
			return name;
		}

		@Override
		public void run() {

			try {
				Thread.sleep(r.nextInt(1000) + 2000);
			} catch (InterruptedException e) {
                System.out.println("线程断开了");
//				e.printStackTrace();
			}
			System.out.println("任务" + name + "完成");

		}

	}

}

测试结果