深入研究线程池

继上一篇提到了线程池,接下来我们来深入探讨和研究线程池

一.什么是线程池?

线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合.
注意这里用了线程集合的概念是我生造的,目的是为了区分执行一批应用逻辑的多个线程和
线程组的区别.关于线程组的概念请参阅基础部分.

一般而言,线程池有以下几个部分:

1.完成主要任务的一个或多个线程.

2.用于调度管理的管理线程.

3.要求执行的任务队列.

那么如果一个线程循环执行一段代码是否是线程池?
如果极端而言,应该算,但实际上循环代码应该算上一个逻辑单元.我们说最最弱化的线程池
应该是循环执行多个逻辑单元.也就是有一批要执行的任务,这些任务被独立为多个不同的执行
单元.比如:

int x = 0;
while(true){
x ++;
}

这就不能说循环中执行多个逻辑单元,因为它只是简单地对循环外部的初始变量执行++操作.

而如果已经有一个队列

ArrayList al = new ArrayList();
for(int i=0;i<10000;i++){
al.add(new AClass());
}

然后在一个线程中执行:

while(al.size() != 0){
AClass a = (AClass)al.remove(0);
a.businessMethod();
}

我们说这个线程就是循环执行多个逻辑单元.可以说这个线程是弱化的线程池.我们习惯上把这些

相对独立的逻辑单元称为任务.

二.为什么要创建线程池?

线程池属于对象池.所有对象池都具有一个非常重要的共性,就是为了最大程度复用对象.那么
线程池的最重要的特征也就是最大程度利用线程.

从编程模型模型上说讲,在处理多任务时,每个任务一个线程是非常好的模型.如果确实可以这么
做我们将可以使用编程模型更清楚,更优化.但是在实际应用中,每个任务一个线程会使用系统限
入"过度切换"和"过度开销"的泥潭.
打个比方,如果可能,生活中每个人一辆房车,上面有休息,娱乐,餐饮等生活措施.而且道路交道永远
不堵车,那是多么美好的梦中王国啊.可是残酷的现实告诉我们,那是不可能的.不仅每个人一辆车
需要无数多的社会资源,而且地球上所能容纳的车辆总数是有限制的.

首先,创建线程本身需要额外(相对于执行任务而必须的资源)的开销.

作业系统在每创建一个线程时,至少需要创建以下资源:

1.线程内核对象用于对线程上下文的管理.

2.用户模式执行栈.

3.内核模式执行栈.

这些资源被线程占有后作业系统和用户都无法使用.

相反的过程,销毁线程需要回收资源,也需要一定开销.

其次,过多的线程将导致过度的切换.
线程切换带来的性能更是不可估量.系统完成线程切换要经过以下过程:
从用户模式切换到内核模式.
将CPU寄存器的值保存到当前线程的内核对象中.
打开一个自旋锁,根据调度策略决定下一个要执行的线程.释放自旋锁,如果要执行的线程不是同一
进程中的线程,还需要切换虚拟内存等进程环境.
将要执行的线程的内核对象的值写到CPU寄存器中.
切换到用户模式执行新线程的执行逻辑.

以上开销对于用户要执行的任务而言,都是额外的.更不可容忍的是,如果用户的任务逻辑都是很小
的单元,而新分配线程和线程切换的开销与任务逻辑需要的开销的比例可能会10:1,100:1,1000:1.

也就是你花了1000$买的衣服只穿了一天!

所以线程池的目的就是为了减少创建和切换线程的额外开销,利用已经的线程多次循环执行多个任
务从而提高系统的处理能力.也就是在"社会主义初级阶段"一件衣服应该尽量多穿一些天数.

[扩展知识]

尽管目前绝大多数JVM实现都是一个Java线程对应一个作业系统线程,但事实上(如果是我来实现JVM)
完全可以用一个作业系统线程执行多个Java线程,因为对于作业系统线程来说Java线程就是一个任务.
而且无论是作业系统线程或Java线程中都可以更细地划分为超细线程(纤程),即在线程内部实现对纤
程的调度利用纤程来执行任务.

三.如何实现线程池?

一个线程池至少应该具有以下几个方面的功能:

1.提供一个任务接口以便用户加入任务

由于Java不支持方法指针,所以操作(方法)只能绑定在对象上,将拥有操作的队象放入队列中,以便
工作线程能按一定策略获取对象然后执行其上的方法.

这里需要有两个组件,一是规定操作的任务接口:

interface ITask{
public void task();
}

一是存放操作的容器.容器可以根据调度策略来选择或自己实现,比如一个最简单的FIFO策略的容器

可以用LinkedList来实现.需要注意的是对这个容器的存取需要同步:

class TaskList{
private LinkedList<ITask> tl = new LinkedList();
public synchronized void addTask(ITask task){
this.tl.add(task);

//notifyAll();
}
//加上addFistTask和addLastTask

public synchronized ITask getTask(){
if(this.size() <= 0)
wait();
return this.tl.poll();
}
//加上getFistTask和getLastTask

public synchronized int getCount(){
return this.tl.size();
}
public synchronized void removeAll(){
this.tl.clear();
}

}

加上addFistTask和addLastTask/getFistTask和getLastTask实现就可以实现简单的优先级调度.

2.工作线程

我们把用来执行用户任务的线程称为工作线程,工作线程就是不断从队列中获取任务对象并执行对象
上的业务方法:

class WorkThread extends Thread{
private TaskList list;
//多个工作线程共同从一个任务队列中获取任务,所以要从外面传入一个任务队列.
public WorkThread(String name,TaskList list){
super(name);
this.list = list;
}
public void run(){
while(true){
ITask task = null;

task = list.getTask();
if(task != null) task.task();
}
}
}

在基础知识部分已经介绍了对线程状态的标记控制,请参照前面的知识自己加入对线线程状态的判断.

完成了这几个基础部分,就需要有一个对工作线程的调度线程.完成以下几个功能:

1.生成需要的工作线程.

由于创建线程需要一定的开销,一定要注意所创建的所有线程不能超一个设定
的最大值.建议最大值不要超25.

2.动态自适应调整集合中线程数.

当有太多的线程处于闲置状态时(队列中没有任务),应该按一定比例
销毁闲置了一定时的线程.如果队列中任务队列积压太多而工作线程总数没有超最大线程数时应该及时
创建工作线程直至达到是大值.

3.需要一个专门的后台线程定时扫描队列中任务与正在工作的线程总数,闲置的线程总数.

以上功能有不同优化方法实现,可以参考JDK的线程池实现.

 

在开始之前我们需要回答一个问题，为什么我们需要线程池？

因为如果我们需要频繁的创建，使用并销毁我们的线程，那么我们的应用可能需要对创建与销毁开销许多的 CPU ,这样无疑对我们服务器不是一种负载。
于是乎，懒惰的程序猿就想能不能尽量少的创建与销毁线程，尽可能的重复利用线程？
于是乎，线程池就诞生了

总结：线程池就是为了避免我们程序中大量的去创建与销毁线程，而实现的一种统一管理与分配线程资源的线程集合。

在JDK中一般我们有以下四种的线程池：

每种线程池除了可以直接通过Executors来实例化外，也可以通过传入ThreadFactory来完成。默认的ThreadFactory是Executors的一个内容类，代码为：

 

static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}