简单线程池-实例

Task： 目标任务接口类，代表我们要执行的任务。

TaskQueue：任务队列，可以用Queue的随便一个子集。

WorkThread：工作线程，线程池的工作线程，用于去任务队列里取任务调度执行。

ThreadPoolService：线程池服务类，用于构造线程池，开始，关闭线程池等。

SimpleTest：具体任务类，继承Task

Task：

package com.mylearn.threadpool;

/**

 * Created by IntelliJ IDEA.

 * User: yingkh

 * Date: 13-3-19

 * Time: 下午5:17

 * CopyRight:360buy

 * Descrption:  这是代表任务的抽象类（当然接口更好），其中定义了一个deal（）方法，集成Task抽象类的

 * 子类需要实现这个方法，并把这个任务需要完成的具体工作在deal（）方法编码实现。线程池中

 * 的线程之所以被创建，就是为了执行各种各样数量繁多的任务的，为了方便线程对任务的处理，

 * 我们需要用Task抽象类来保证任务的具体工作统一放在deal（）方法里来完成，这样也使代码更加

 * 规范

 * To change this template use File | Settings | File Templates.

 */

public abstract class Task {

    public enum State {

        NEW,    //新建

        RUNNING,     //执行中

        FINISHIED       //已完成

    }

    private State state = State.NEW;

    public abstract void deal();  //具体业务目标方法

    public State getState() {

        return state;

    }

    public void setState(State state) {

        this.state = state;

    }

}

TaskQueue：

package com.mylearn.threadpool;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

/**

 * Created by IntelliJ IDEA.

 * User: yingkh

 * Date: 13-3-19

 * Time: 下午6:20

 * CopyRight:360buy

 * Descrption:   任务队列

 * 在同一时刻，可能有很多任务需要执行，而程序在同一时刻只能执行一定数量的任务，当需要执行的任务数超过了

 * 程序所能承受的任务数时怎么办呢？这就有了先执行哪些任务，后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种，它采用的是

 * FIFO的方式。也就是按任务到达的先后顺序执行。

 * To change this template use File | Settings | File Templates.

 */

public class TaskQueue {

    private List<Task> queue = new LinkedList<Task>();//这里使用LinkedList类来保存任务到达的先后顺序

    /**

     * 用于一个新任务到达时，将它添加到任务队列中，这

     * @param task

     */

    public synchronized void addTask(Task task) {

        if (task != null) {

            queue.add(task);

        }

    }

    /**

     * 用于任务执行完毕时，将它从任务队里清除出去

     * @param task

     */

    public synchronized void finishTask(Task task) {

        if (task != null) {

            task.setState(Task.State.FINISHIED);

            queue.remove(task);

        }

    }

    /**

     * 用于取得当前要执行的任务

     * @return

     */

    public synchronized Task getTask() {

        Iterator<Task> it = queue.iterator();

        Task task;

        while (it.hasNext()) {

            task = it.next();

            //找到第一个新建的任务，设为执行中，返回

            if (Task.State.NEW.equals(task.getState())) {

                task.setState(Task.State.RUNNING);

                return task;

            }

        }

        return null;

    }

}

WorkThread:

package com.mylearn.threadpool;

/**

 * Created by IntelliJ IDEA.

 * User: yingkh

 * Date: 13-3-20

 * Time: 上午9:54

 * CopyRight:360buy

 * Descrption: 执行任务的线程类

 * 专门处理任务队列中的待执行任务

 * To change this template use File | Settings | File Templates.                                                                                                                                             

 */

public class WorkThread implements Runnable {

    private ThreadPoolService service;

    public WorkThread(ThreadPoolService threadPoolService) {

        this.service = threadPoolService;

    }

    public void run() {

        //判断线程池是否在运行状态

        while (service.isRunning()) {

            // 获取任务，执行

            TaskQueue queue = service.getTaskQueue();

            Task task = queue.getTask();

            if (task != null) {

                task.deal();

            }

            //完成任务后设置移除队列

            queue.finishTask(task);

        }

    }

}

ThreadPoolService:

package com.mylearn.threadpool;

import java.util.ArrayList;

import java.util.List;

/**

 * Created by IntelliJ IDEA.

 * User: yingkh

 * Date: 13-3-20

 * Time: 上午9:54

 * CopyRight:360buy

 * Descrption:   线程池服务类

 *

 * 这是线程池最核心的一个类。它在被创建的时候就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start（）方法              

  * 启动线程池服务时，它们才能真正运行。

 * To change this template use File | Settings | File Templates.

 */

public class ThreadPoolService {

    public static final int THREAD_COUNT = 5; //初始线程数,spring的话定义了几个最小值，域阀值

    private TaskQueue queue = new TaskQueue(); // 任务队列

    private Status stats = Status.NEW;   //初始状态

    public enum Status {      //定义线程池的几个状态

        NEW,

        RUNNING,

        STOP

    }

    private List<Thread> threads = new ArrayList<Thread>(); //初始线程

    //构造时创建几个初始任务线程

    public ThreadPoolService() {

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

            WorkThread t = new WorkThread(this);

            threads.add(new Thread(t));

        }

    }

    /**

     * 启动线程，依次执行任务线程

     */

    public void start() {

        this.stats = Status.RUNNING;

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

             threads.get(i).start();

         }

    }

    public void stop() {

        this.stats = Status.STOP;

    }

    public boolean isRunning() {

        return  stats == Status.RUNNING;

    }

    /**

     * 加入任务到线程池队列

     * @param task

     */

    public void runTask(Task task) {

        queue.addTask(task);

    }

    protected TaskQueue getTaskQueue() {

        return queue;

    }

}

Client:

package com.mylearn.threadpool;

/**

 * Created by IntelliJ IDEA.

 * User: yingkuohao

 * Date: 13-10-29

 * Time: 下午2:30

 * CopyRight:360buy

 * Descrption:

 * To change this template use File | Settings | File Templates.

 */

public class Client {

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

        ThreadPoolService threadPoolService = new ThreadPoolService();                                                                                                                               

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

            threadPoolService.runTask(new SimpleTest(i + ""));

        }

        threadPoolService.start();

        Thread.sleep(1000); //等待所有线程执行完毕，睡一秒

        threadPoolService.stop();

    }

}