java中通用的线程池实例代码

package com.smart.frame.task.autotask;

import java.util.collection;
import java.util.vector;

/**
 * 任务分发器
 */
public class taskmanage extends thread
{
    protected vector<runnable> tasks = new vector<runnable>();
    protected boolean running = false;
    protected boolean stopped = false;
    protected boolean paused = false;
    protected boolean killed = false;
    private threadpool pool;

    public taskmanage(threadpool pool)
    {
        this.pool = pool;
    }

    public void puttask(runnable task)
    {
        tasks.add(task);
    }

    public void puttasks(runnable[] tasks)
    {
        for (int i = 0; i < tasks.length; i++)
            this.tasks.add(tasks[i]);
    }

    public void puttasks(collection<runnable> tasks)
    {
        this.tasks.addall(tasks);
    }

    protected runnable poptask()
    {
        if (tasks.size() > 0) return (runnable) tasks.remove(0);
        else return null;
    }

    public boolean isrunning()
    {
        return running;
    }

    public void stoptasks()
    {
        stopped = true;
    }

    public void stoptaskssync()
    {
        stoptasks();
        while (isrunning())
        {
            try
            {
                sleep(5);
            }
            catch (interruptedexception e)
            {
                taskexception.getresultmessage(e);
            }
        }
    }

    public void pausetasks()
    {
        paused = true;
    }

    public void pausetaskssync()
    {
        pausetasks();
        while (isrunning())
        {
            try
            {
                sleep(5);
            }
            catch (interruptedexception e)
            {
                taskexception.getresultmessage(e);
            }
        }
    }

    public void kill()
    {
        if (!running) interrupt();
        else killed = true;
    }

    public void killsync()
    {
        kill();
        while (isalive())
        {
            try
            {
                sleep(5);
            }
            catch (interruptedexception e)
            {
                taskexception.getresultmessage(e);
            }
        }
    }

    public synchronized void starttasks()
    {
        running = true;
        this.notify();
    }

    public synchronized void run()
    {
        try
        {
            while (true)
            {
                if (!running || tasks.size() == 0)
                {
                    pool.notifyforidlethread();
                    this.wait();
                }
                else
                {
                    runnable task;
                    while ((task = poptask()) != null)
                    {
                        task.run();
                        if (stopped)
                        {
                            stopped = false;
                            if (tasks.size() > 0)
                            {
                                tasks.clear();
                                system.out.println(thread.currentthread().getid() + ": tasks are stopped");
                                break;
                            }
                        }
                        if (paused)
                        {
                            paused = false;
                            if (tasks.size() > 0)
                            {
                                system.out.println(thread.currentthread().getid() + ": tasks are paused");
                                break;
                            }
                        }
                    }
                    running = false;
                }

                if (killed)
                {
                    killed = false;
                    break;
                }
            }
        }
        catch (interruptedexception e)
        {
            taskexception.getresultmessage(e);
            return;
        }
    }
}

package com.smart.frame.task.autotask;

import java.util.collection;
import java.util.iterator;
import java.util.vector;

/**
 * 线程池
 */
public class threadpool
{
    protected int maxpoolsize = taskconfig.maxpoolsize;
    protected int initpoolsize = taskconfig.initpoolsize;
    protected vector<taskmanage> threads = new vector<taskmanage>();
    protected boolean initialized = false;
    protected boolean hasidlethread = false;

    public threadpool()
    {
        super();
    }

    public threadpool(int maxpoolsize, int initpoolsize)
    {
        this.maxpoolsize = maxpoolsize;
        this.initpoolsize = initpoolsize;
    }

    public void init()
    {
        initialized = true;
        for (int i = 0; i < initpoolsize; i++)
        {
            taskmanage thread = new taskmanage(this);
            thread.start();
            threads.add(thread);
        }
    }

    public void setmaxpoolsize(int maxpoolsize)
    {
        this.maxpoolsize = maxpoolsize;
        if (maxpoolsize < getpoolsize()) setpoolsize(maxpoolsize);
    }

    /**
     * 重设当前线程数 若需杀掉某线程，线程不会立刻杀掉，而会等到线程中的事
     * 务处理完成 但此方法会立刻从线程池中移除该线程，不会等待事务处理结束
     */
    public void setpoolsize(int size)
    {
        if (!initialized)
        {
            initpoolsize = size;
            return;
        }
        else if (size > getpoolsize())
        {
            for (int i = getpoolsize(); i < size && i < maxpoolsize; i++)
            {
                taskmanage thread = new taskmanage(this);
                thread.start();
                threads.add(thread);
            }
        }
        else if (size < getpoolsize())
        {
            while (getpoolsize() > size)
            {
                taskmanage th = (taskmanage) threads.remove(0);
                th.kill();
            }
        }
    }

    public int getpoolsize()
    {
        return threads.size();
    }

    protected void notifyforidlethread()
    {
        hasidlethread = true;
    }

    protected boolean waitforidlethread()
    {
        hasidlethread = false;
        while (!hasidlethread && getpoolsize() >= maxpoolsize)
        {
            try
            {
                thread.sleep(5);
            }
            catch (interruptedexception e)
            {
                taskexception.getresultmessage(e);
                return false;
            }
        }

        return true;
    }

    public synchronized taskmanage getidlethread()
    {
        while (true)
        {
            for (iterator<taskmanage> itr = threads.iterator(); itr.hasnext();)
            {
                taskmanage th = (taskmanage) itr.next();
                if (!th.isrunning()) return th;
            }

            if (getpoolsize() < maxpoolsize)
            {
                taskmanage thread = new taskmanage(this);
                thread.start();
                threads.add(thread);
                return thread;
            }

            if (waitforidlethread() == false) return null;
        }
    }

    public void processtask(runnable task)
    {
        taskmanage th = getidlethread();
        if (th != null)
        {
            th.puttask(task);
            th.starttasks();
        }
    }

    public void processtasksinsinglethread(runnable[] tasks)
    {
        taskmanage th = getidlethread();
        if (th != null)
        {
            th.puttasks(tasks);
            th.starttasks();
        }
    }

    public void processtasksinsinglethread(collection<runnable> tasks)
    {
        taskmanage th = getidlethread();
        if (th != null)
        {
            th.puttasks(tasks);
            th.starttasks();
        }
    }

}

package com.smart.frame.task.autotask;

public class toptask implements runnable
{

    private threadpool pool;

    public toptask()
    {
        super();
    }

    public toptask(threadpool pool)
    {
        super();
        this.pool = pool;
    }

    @override
    public void run()
    {
        init();
        start();
    }

    /**
     * 初始化验证权限、参数之类
     */
    public void init()
    {

    }

    /**
     * 开始自动任务
     */
    public void start()
    {
        for (int i = 0; i < 10; i++)
        {
            pool.processtask(new beginauto());
        }
    }
}
/**
 * 实现类
 */
class beginauto implements runnable
{
    @override
    public void run()
    {
        system.out.println(thread.currentthread().getid() + "..................");
    }

}