java预先创建核心线程,【JavaEE】自主实现java线程池的核心部分

首先思考，线程池最基本的目的是什么？

线程存在“创建”、“运行”、“结束(销毁)”的三个过程，形成所谓的“线程生命周期”。

在CS模式的服务器端，服务器在侦听客户端连接时，每侦听到一个客户端连接请求，都将产生一个线程，这个线程负责维护与客户端的持续通信。若存在大量客户端连接服务器的情况，那么，就会存在大量线程的产生。这种情况，由于每一个线程通常存在比较长的时间，因此，情况不是非常严重。

再看RMI框架：在RMI服务器端，也存在每侦听到一个客户端，就需要产生一个线程，完成客户端对特定方法的调用。这个过程本质上只是执行了一个方法，所以，这个线程将很快结束。那么，在大量客户端都存在向服务器端进行RMI请求的情况下，服务器端会存在海量的线程的“创建”、“销毁”动作。

事实上，线程的“创建”是耗时、耗资源的！如果非常频繁地创建、销毁线程，将使得服务器效率降低！

为避免上述情况，考虑一种可能性：

先创建一些线程，当线程运行结束后，并不直接销毁，而是将它们存放到一个“线程池”中；若有新的线程需求，直接从线程池中获取它们，从而避免频繁、耗资源的线程创建和销毁工作。

上述讨论意味着，每创建一个线程，这个线程都一直保持“运行”状态，直到整个线程池被用户终结，才会结束并销毁。控制同时“运行”的线程数量是必须的。

这里存在一个难点：

如何让一个始终保持运行状态的线程，能切换不同的工作内容？

我们可以设置一个接口，实现接口的类不同，那么，工作内容就不同。代码如下：

public interface ITasker {

void beforeTask();

void task();

void afterTask();

}

这个接口定义了三个方法，实现它的类需要一一实现这些方法。

接下来实现我们执行这些方法的类：

public class Woker implements Runnable{

private volatile ITasker tasker;

private volatile boolean goon;

public Woker() {

lock = new Object();

this.goon = false;

}

public Woker(ITasker tasker) {

lock = new Object();

this.tasker = tasker;

this.goon = false;

}

public void setTasker(ITasker tasker) {

this.tasker = tasker;

}

public void startup() {

if (goon == true) {

return ;

}

goon = true;

new Thread(this).start();

}

public void shutdown() {

if (goon == false) {

return ;

}

goon = false;

}

@Override

public void run() {

while (goon) {

if (tasker != null) {

try {

tasker.beforeTask();

tasker.task();

} catch (Exception e) {

e.printStackTrace();

}

tasker.afterTask();

tasker = null;

}

}

}

}

可以看到，这个类实现了run方法，这个线程一旦开启，就是一个死循环，需要shutdown方法来关闭它。

因为，线程池需要通吃管理很多的线程，那么就会有很多的Woker类。这时，我们需要一个总的容器来管理这些Woker类。

但是，我们还需要考虑如下问

题：

1、应该限定“核心线程”数量； 所谓“核心线程”是一直处在待执行状态的线程；

2、当核心线程数量达到极值，后面产生的线程不再进入空线程池；

3、还要控制最大并行线程数量； 若最大并行线程数量达到极值，则，对于用户产生的新的线程需 求，不再立刻满足，而是等待若干时间，再从空线程池中获取可 用线程。

4、对于线程池的结束，应该考虑到正在执行中的线程的“强制结

束”，或者，“等待结束”这两种处理方式。

public class ThreadPool {

private final Queue freeThreadList;

private final List busyThreadList;

public ThreadPool() {

//这里用的是队列，因为队列的特性是先入先出，而且是线程安全的

freeThreadList = new ConcurrentLinkedQueue();

//这里用的是链表，因为我们需要不断的增加或者删除某个节点。

busyThreadList = new LinkedList<>();

//预先建立5个线程

createWorker(5);

}

public boolean stop() {

Worker worker;

if (busyThreadList.isEmpty()) {

while ((worker = freeThreadList.poll()) != null) {

worker.stop();

}

return true;

}

return false;

}

private void createWorker(int count) {

for (int i = 0; i < count; i++) {

Worker worker = new Worker(this);

worker.start();

freeThreadList.add(worker);

}

}

public void setTask(Tasker tasker) {

Worker worker = freeThreadList.poll();

if (worker == null) {

createWorker(3);

worker = freeThreadList.poll();

}

worker.setTasker(tasker);

busyThreadList.add(worker);

}

void workerFree(Worker worker) {

busyThreadList.remove(worker);

//这里的20是自己设定的核心线程池数量，也可以作为一个成员来在外面初始化

if (freeThreadList.size() < 20) {

freeThreadList.offer(worker);

} else {

worker.stop();

}

}

}

有了ThreadPool类，对于执行完一个Woker，要把它放到freeThreadList里面。我们需要对Woker类进行修改，其实很简单，我们可以给Woker类一个成员，然后在ThreadPool类当我们new Woker时，将自己设置进去。在执行完Woker类里面ITasker接口的方法时，我们需要在Woker类里面调用threadPool的workerFree()方法，同时传递自己作为参数。

到这里，我们也就实现了线程池的核心代码。