Java 线程池的原理与完成ITeye - 千亿集团

Java 线程池的原理与完成ITeye

2019-01-14 04:34:07 | 作者: 景浩 | 标签: 线程,使命,履行 | 浏览: 2790

简略介绍

    创立线程有两种办法:承继Thread或完结Runnable。Thread完结了Runnable接口,供给了一个空的run()办法,所以不论是承继Thread仍是完结Runnable,都要有自己的run()办法。
    一个线程创立后就存在,调用start()办法就开端运转(履行run()办法),调用wait进入等候或调用sleep进入休眠期,顺畅运转完毕或休眠被中止或运转过程中出现异常而退出。

wait和sleep比较:
      sleep办法有:sleep(long millis),sleep(long millis, long nanos),调用sleep办法后,当时线程进入休眠期,暂停履行,但该线程持续具有监督资源的一切权。抵达休眠时刻后线程将持续履行,直到完结。若在休眠期另一线程中止该线程,则该线程退出。
      wait办法有:wait(),wait(long timeout),wait(long timeout, long nanos),调用wait办法后,该线程抛弃监督资源的一切权进入等候状况;
      wait():等候有其它的线程调用notify()或notifyAll()进入调度状况,与其它线程一起抢夺监督。wait()相当于wait(0),wait(0, 0)。
      wait(long timeout):当其它线程调用notify()或notifyAll(),或时刻抵达timeout亳秒,或有其它某线程中止该线程,则该线程进入调度状况。
      wait(long timeout, long nanos):相当于wait(1000000*timeout + nanos),只不过时刻单位为纳秒。



线程池:
    多线程技能首要处理处理器单元内多个线程履行的问题,它能够明显削减处理器单元的搁置时刻,添加处理器单元的吞吐能力。
   
    假定一个服务器完结一项使命所需时刻为:T1 创立线程时刻,T2 在线程中履行使命的时刻,T3 毁掉线程时刻。
   
    假如:T1 + T3 远大于 T2,则能够选用线程池,以进步服务器功能。
                一个线程池包含以下四个根本组成部分:
                1、线程池办理器(ThreadPool):用于创立并办理线程池,包含 创立线程池,毁掉线程池,添加新使命;
                2、作业线程(PoolWorker):线程池中线程,在没有使命时处于等候状况,能够循环的履行使命;
                3、使命接口(Task):每个使命有必要完结的接口,以供作业线程调度使命的履行,它首要规则了使命的进口,使命履行完后的收尾作业,使命的履行状况等;
                4、使命行列(taskQueue):用于寄存没有处理的使命。供给一种缓冲机制。
               
    线程池技能正是重视怎么缩短或调整T1,T3时刻的技能,然后进步服务器程序功能的。它把T1,T3分别安排在服务器程序的发动和完毕的时刻段或许一些闲暇的时刻段,这样在服务器程序处理客户恳求时,不会有T1,T3的开销了。

    线程池不只调整T1,T3发生的时刻段,而且它还明显削减了创立线程的数目,看一个比如:

    假定一个服务器一天要处理50000个恳求,而且每个恳求需求一个独自的线程完结。在线程池中,线程数一般是固定的,所以发生线程总数不会超越线程池中线程的数目,而假如服务器不使用线程池来处理这些恳求则线程总数为50000。一般线程池巨细是远小于50000。所以使用线程池的服务器程序不会为了创立50000而在处理恳求时浪费时刻,然后进步功率。


/** 线程池类,作业线程作为其内部类 **/

package org.ymcn.util;

import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import org.apache.log4j.Logger;

/**
* 线程池
* 创立线程池,毁掉线程池,添加新使命
*
* @author obullxl
*/
public final class ThreadPool {
    private static Logger logger = Logger.getLogger(ThreadPool.class);
    private static Logger taskLogger = Logger.getLogger("TaskLogger");

    private static boolean debug = taskLogger.isDebugEnabled();
    // private static boolean debug = taskLogger.isInfoEnabled();
    /* 单例 */
    private static ThreadPool instance = ThreadPool.getInstance();

    public static final int SYSTEM_BUSY_TASK_COUNT = 150;
    /* 默许池中线程数 */
    public static int worker_num = 5;
    /* 现已处理的使命数 */
    private static int taskCounter = 0;

    public static boolean systemIsBusy = false;

    private static List Task taskQueue = Collections
            .synchronizedList(new LinkedList Task
    /* 池中的一切线程 */
    public PoolWorker[] workers;

    private ThreadPool() {
        workers = new PoolWorker[5];
        for (int i = 0; i workers.length; i++) {
            workers[i] = new PoolWorker(i);
        }
    }

    private ThreadPool(int pool_worker_num) {
        worker_num = pool_worker_num;
        workers = new PoolWorker[worker_num];
        for (int i = 0; i workers.length; i++) {
            workers[i] = new PoolWorker(i);
        }
    }

    public static synchronized ThreadPool getInstance() {
        if (instance == null)
            return new ThreadPool();
        return instance;
    }
    /**
    * 添加新的使命
    * 每添加一个新使命,都要唤醒使命行列
    * @param newTask
    */
    public void addTask(Task newTask) {
        synchronized (taskQueue) {
            newTask.setTaskId(++taskCounter);
            newTask.setSubmitTime(new Date());
            taskQueue.add(newTask);
            /* 唤醒行列, 开端履行 */
            taskQueue.notifyAll();
        }
        logger.info("Submit Task " + newTask.getTaskId() + " : "
                + newTask.info());
    }
    /**
    * 批量添加新使命
    * @param taskes
    */
    public void batchAddTask(Task[] taskes) {
        if (taskes == null || taskes.length == 0) {
            return;
        }
        synchronized (taskQueue) {
            for (int i = 0; i taskes.length; i++) {
                if (taskes[i] == null) {
                    continue;
                }
                taskes[i].setTaskId(++taskCounter);
                taskes[i].setSubmitTime(new Date());
                taskQueue.add(taskes[i]);
            }
            /* 唤醒行列, 开端履行 */
            taskQueue.notifyAll();
        }
        for (int i = 0; i taskes.length; i++) {
            if (taskes[i] == null) {
                continue;
            }
            logger.info("Submit Task " + taskes[i].getTaskId() + " : "
                    + taskes[i].info());
        }
    }
    /**
    * 线程池信息
    * @return
    */
    public String getInfo() {
        StringBuffer sb = new StringBuffer();
        sb.append("\nTask Queue Size:" + taskQueue.size());
        for (int i = 0; i workers.length; i++) {
            sb.append("\nWorker " + i + " is "
                    + ((workers[i].isWaiting()) ? "Waiting." : "Running."));
        }
        return sb.toString();
    }
    /**
    * 毁掉线程池
    */
    public synchronized void destroy() {
        for (int i = 0; i worker_num; i++) {
            workers[i].stopWorker();
            workers[i] = null;
        }
        taskQueue.clear();
    }

    /**
    * 池中作业线程
    *
    * @author obullxl
    */
    private class PoolWorker extends Thread {
        private int index = -1;
        /* 该作业线程是否有用 */
        private boolean isRunning = true;
        /* 该作业线程是否能够履行新使命 */
        private boolean isWaiting = true;

        public PoolWorker(int index) {
            this.index = index;
            start();
        }

        public void stopWorker() {
            this.isRunning = false;
        }

        public boolean isWaiting() {
            return this.isWaiting;
        }
        /**
        * 循环履行使命
        * 这也许是线程池的关键所在
        */
        public void run() {
            while (isRunning) {
                Task r = null;
                synchronized (taskQueue) {
                    while (taskQueue.isEmpty()) {
                        try {
                            /* 使命行列为空,则等候有新使命参加然后被唤醒 */
                            taskQueue.wait(20);
                        } catch (InterruptedException ie) {
                            logger.error(ie);
                        }
                    }
                    /* 取出使命履行 */
                    r = (Task) taskQueue.remove(0);
                }
                if (r != null) {
                    isWaiting = false;
                    try {
                        if (debug) {
                            r.setBeginExceuteTime(new Date());
                            taskLogger.debug("Worker " + index
                                    + " start execute Task " + r.getTaskId() + "
                            if (r.getBeginExceuteTime().getTime()
                                    - r.getSubmitTime().getTime() 1000)
                                taskLogger.debug("longer waiting time. "
                                        + r.info() + ", " + index + " ,time:"
                                        + (r.getFinishTime().getTime() - r
                                                .getBeginExceuteTime().getTime()));
                        }
                        /* 该使命是否需求当即履行 */
                        if (r.needExecuteImmediate()) {
                            new Thread(r).start();
                        } else {
                            r.run();
                        }
                        if (debug) {
                            r.setFinishTime(new Date());
                            taskLogger.debug("Worker " + index
                                    + " finish task " + r.getTaskId() + "
                            if (r.getFinishTime().getTime()
                                    - r.getBeginExceuteTime().getTime() 1000)
                                taskLogger.debug("longer execution time. "
                                        + r.info() + ", " + index + " ,time:"
                                        + (r.getFinishTime().getTime() - r
                                                .getBeginExceuteTime().getTime()));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        logger.error(e);
                    }
                    isWaiting = true;
                    r = null;
                }
            }
        }
    }
}

/** 使命接口类 **/

package org.ymcn.util;

import java.util.Date;

/**
* 一切使命接口
* 其他使命有必要承继访类
*
* @author obullxl
*/
public abstract class Task implements Runnable {
    // private static Logger logger = Logger.getLogger(Task.class);
    /* 发生时刻 */
    private Date generateTime = null;
    /* 提交履行时刻 */
    private Date submitTime = null;
    /* 开端履行时刻 */
    private Date beginExceuteTime = null;
    /* 履行完结时刻 */
    private Date finishTime = null;

    private long taskId;

    public Task() {
        this.generateTime = new Date();
    }

    /**
    * 使命履行进口
    */
    public void run() {
        /**
        * 相关履行代码
        *
        * beginTransaction();
        *
        * 履行过程中或许发生新的使命 subtask = taskCore();
        *
        * commitTransaction();
        *
        * 添加新发生的使命 ThreadPool.getInstance().batchAddTask(taskCore());
        */
    }

    /**
    * 一切使命的中心 所以特别的事务逻辑履行之处
    *
    * @throws Exception
    */
    public abstract Task[] taskCore() throws Exception;

    /**
    * 是否用到数据库
    *
    * @return
    */
    protected abstract boolean useDb();

    /**
    * 是否需求当即履行
    *
    * @return
    */
    protected abstract boolean needExecuteImmediate();

    /**
    * 使命信息
    *
    * @return String
    */
    public abstract String info();

    public Date getGenerateTime() {
        return generateTime;
    }

    public Date getBeginExceuteTime() {
        return beginExceuteTime;
    }

    public void setBeginExceuteTime(Date beginExceuteTime) {
        this.beginExceuteTime = beginExceuteTime;
    }

    public Date getFinishTime() {
        return finishTime;
    }

    public void setFinishTime(Date finishTime) {
        this.finishTime = finishTime;
    }

    public Date getSubmitTime() {
        return submitTime;
    }

    public void setSubmitTime(Date submitTime) {
        this.submitTime = submitTime;
    }

    public long getTaskId() {
        return taskId;
    }

    public void setTaskId(long taskId) {
        this.taskId = taskId;
    }

}



转自:http://hi.baidu.com/obullxl/blog/item/ee50ad1ba8e8ff1f8718bf66.html

script type="text/javascript" // ![CDATA[ google_ad_client = "ca-pub-2876867208357149"; /* blogjava默许,主张保存 */ google_ad_slot = "0418982663"; google_ad_width = 468; google_ad_height = 60; // ]] /script script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js" // ![CDATA[ // ]] /script

版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表千亿集团立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章