建立自己的JAVA线程池

为什么要建立线程池？

 

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

 

线程池是什么？

 

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

 

怎么建立线程池？

 

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

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

 

2. 工作线程
 

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

 

3. 工作队列
 

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

4. 工作任务
 

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

 

 线程管理类：

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();    
        }    
    }    
}

 

 

工作线程类：

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;    
    }    
}

 

 

工作任务接口：

 

/**   
 * 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();    
}

 

 

工作任务类：

/**   
 * 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());    
    }    
   
}

 

 

 

 

线程池测试类：

 

/**   
 * 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();    
    }       
}