建立自己的JAVA线程池

建立自己的JAVA线程池

为什么要建立线程池？

 

在多线程项目中，如果建立的线程过多，反而可能导致运行速度大大减慢，这是由于线程建立所花费的时间和资源都比较多。
所以我们在多线程中必须很好地来管理线程， 在很好利用多线程能“同步工作”的好处之外，更有效地提高程序运行速度。

 

线程池是什么？

 

线程池是指具有固定数量的线程组成的一种组件。这些线程用来循环执行多个应用逻辑。

 

怎么建立线程池？

 

线程池主要包括4个部分，它们是：
1. 线程管理
 

主要是用来建立，启动，销毁工作线程和把工作任务加入工作线程。

 

2. 工作线程
 

它是真正的线程类，运行工作任务。

 

3. 工作队列
 

它是用来封装线程的容器。

4. 工作任务
 

它是实现应用逻辑的具体类。

 

 线程管理类：

<SPAN style="COLOR: #3366ff">import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * ThreadPoolManager.java
 *
 * Copyright (C)  2008 State Street Corporation. All Rights Reserved.
 *
 */

/**
 * the thread pool manager, is responsible for starting and stopping the work thread.
 *
 * @author  e458487
 * @version 1.0
 */
public class ThreadPoolManager {

    private static final int DEFAULT_POOL_SIZE = 4;
    private List<WorkThread> threadPool;
    private Queue<Task> taskQueue;
    private int poolSize;

    public ThreadPoolManager() {
        this(DEFAULT_POOL_SIZE);
    }

    public ThreadPoolManager(int poolSize) {
        if(poolSize <= 0) {
            this.poolSize = DEFAULT_POOL_SIZE;
        }else {
            this.poolSize = poolSize;
        }
        threadPool = new ArrayList<WorkThread>(this.poolSize);
        taskQueue = new ConcurrentLinkedQueue<Task>();
        startup();
    }

    public void startup() {
        System.out.println("start work thread...");
        synchronized(taskQueue) {
            for(int i = 0; i < this.poolSize; i++) {
                WorkThread workThread = new WorkThread(taskQueue);
                threadPool.add(workThread);
                workThread.start();
            }
        }
    }

    public void shutdown() {
        System.out.println("shutdown work thread...");
        synchronized(taskQueue) {
            for(int i = 0; i < this.poolSize; i++) {
                threadPool.get(i).shutdown();
            }

            System.out.println("done...");
        }
    }

    public void addTask(Task task) {
        synchronized(taskQueue) {
            taskQueue.add(task);
            taskQueue.notify();
        }
    }
}</SPAN>

import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* ThreadPoolManager.java
*
* Copyright (C)  2008 State Street Corporation. All Rights Reserved.
*
*/
/**
* the thread pool manager, is responsible for starting and stopping the work thread.
*
* @author  e458487
* @version 1.0
*/
public class ThreadPoolManager {
private static final int DEFAULT_POOL_SIZE = 4;
private List<WorkThread> threadPool;
private Queue<Task> taskQueue;
private int poolSize;
public ThreadPoolManager() {
this(DEFAULT_POOL_SIZE);
}
public ThreadPoolManager(int poolSize) {
if(poolSize <= 0) {
this.poolSize = DEFAULT_POOL_SIZE;
}else {
this.poolSize = poolSize;
}
threadPool = new ArrayList<WorkThread>(this.poolSize);
taskQueue = new ConcurrentLinkedQueue<Task>();
startup();
}
public void startup() {
System.out.println("start work thread...");
synchronized(taskQueue) {
for(int i = 0; i < this.poolSize; i++) {
WorkThread workThread = new WorkThread(taskQueue);
threadPool.add(workThread);
workThread.start();
}
}
}
public void shutdown() {
System.out.println("shutdown work thread...");
synchronized(taskQueue) {
for(int i = 0; i < this.poolSize; i++) {
threadPool.get(i).shutdown();
}
System.out.println("done...");
}
}
public void addTask(Task task) {
synchronized(taskQueue) {
taskQueue.add(task);
taskQueue.notify();
}
}
}

 

工作线程类：

<SPAN style="COLOR: #3366ff">import java.util.Queue;

/**
 * WorkThread.java
 *
 * Copyright (C)  2008 State Street Corporation. All Rights Reserved.
 *
 */

/**
 * the work thread used pull the task of task queue, and execute it.
 *
 * @author  e458487
 * @version 1.0
 */
public class WorkThread extends Thread {

    private boolean shutdown = false;
    private Queue<Task> queue;

    public WorkThread(Queue<Task> queue) {
        this.queue = queue;
    }

    public void run() {
        while(!shutdown) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            System.out.println(Thread.currentThread() + " is running...");
            synchronized(queue) {
                if(!queue.isEmpty()) {
                    Task task = queue.poll();
                    task.execute();
                }else {
                    try {
                        queue.wait(1000);
                        System.out.println(Thread.currentThread() + " wait...");
                    }catch(InterruptedException e) {

                    }
                }
            }
        }
    }

    public void shutdown() {
        shutdown = true;
    }
}</SPAN>

import java.util.Queue;
/**
* WorkThread.java
*
* Copyright (C)  2008 State Street Corporation. All Rights Reserved.
*
*/
/**
* the work thread used pull the task of task queue, and execute it.
*
* @author  e458487
* @version 1.0
*/
public class WorkThread extends Thread {
private boolean shutdown = false;
private Queue<Task> queue;
public WorkThread(Queue<Task> queue) {
this.queue = queue;
}
public void run() {
while(!shutdown) {
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println(Thread.currentThread() + " is running...");
synchronized(queue) {
if(!queue.isEmpty()) {
Task task = queue.poll();
task.execute();
}else {
try {
queue.wait(1000);
System.out.println(Thread.currentThread() + " wait...");
}catch(InterruptedException e) {
}
}
}
}
}
public void shutdown() {
shutdown = true;
}
}

 

工作任务接口：

 

<SPAN style="COLOR: #3366ff">/**
 * Task.java
 *
 * Copyright (C)  2008 State Street Corporation. All Rights Reserved.
 *
 */

/**
 * The task want to execute.
 *
 * @author  e458487
 * @version 1.0
 */
public interface Task {

    public void execute();
}</SPAN>

/**
* Task.java
*
* Copyright (C)  2008 State Street Corporation. All Rights Reserved.
*
*/
/**
* The task want to execute.
*
* @author  e458487
* @version 1.0
*/
public interface Task {
public void execute();
}

 

工作任务类：

<SPAN style="COLOR: #3366ff">/**
 * SimpleTask.java
 *
 * Copyright (C)  2008 State Street Corporation. All Rights Reserved.
 *
 */

/**
 * @author  e458487
 * @version 1.0
 */
public class SimpleTask implements Task {

    /* (non-Javadoc)
     * @see Task#execute()
     */
    public void execute() {
        System.out.println(Thread.currentThread());
    }

}</SPAN>

/**
* SimpleTask.java
*
* Copyright (C)  2008 State Street Corporation. All Rights Reserved.
*
*/
/**
* @author  e458487
* @version 1.0
*/
public class SimpleTask implements Task {
/* (non-Javadoc)
* @see Task#execute()
*/
public void execute() {
System.out.println(Thread.currentThread());
}
}

 

线程池测试类：

<SPAN style="COLOR: #3366ff">/**
 * ThreadPoolDemo.java
 *
 * Copyright (C)  2008 State Street Corporation. All Rights Reserved.
 *
 */

/**
 * @author  e458487
 * @version 1.0
 */
public class ThreadPoolDemo {

    public static void main(String[] args) {
        ThreadPoolManager threadMg = new ThreadPoolManager();

        for(int i = 0; i < 50; i++) {
            threadMg.addTask(new SimpleTask());
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadMg.shutdown();
    }
}</SPAN>