JAVA线程池的简单实现及优先级设置
线程池的基本原理是，首先创建并保持一定数量的线程，当需要使用线程时，我们从池中取得线程，再将需要运行的任务交给线程进行处理，当任务完成后再将其释放回池中。
下面，我给出一个很简单的实现模型，仅供参考。
package org.loon.framework.util.test;
import java.util.LinkedList;
import java.util.List;
/** *//**
* <p>
* Title: LoonFramework
* </p>
* <p>
* Description:
* </p>
* <p>
* Copyright: Copyright (c) 2007
* </p>
* <p>
* Company: LoonFramework
* </p>
*
* @author chenpeng
* @email：[email]ceponline@yahoo.com.cn[/email]
* @version 0.1
*/
public class ThreadPool ...{
private static ThreadPool instance = null;
// 优先级低
public static final int PRIORITY_LOW = 0;
// 普通
public static final int PRIORITY_NORMAL = 1;
// 高
public static final int PRIORITY_HIGH = 2;
// 用以保存空闲连接
private List[] _idxThreads;
// 关闭
private boolean _shutdown = false;
// 线程数量
private int _threadCount = 0;
// debug信息是否输出
private boolean _debug = false;
/** *//**
* 返回ThreadPool实例
*
* @return
*/
public static ThreadPool getInstance() ...{
if (instance == null) ...{
instance = new ThreadPool();
}
return instance;
}
// 初始化线程list
private ThreadPool() ...{
this._idxThreads = new List[] ...{ new LinkedList(), new LinkedList(),
new LinkedList() };
this._threadCount=0;
}
/** *//**
* 同步方法，完成任务后将资源放回线程池中
* @param repool
*/
protected synchronized void repool(Pooled repool) ...{
if (this._shutdown) ...{
if (this._debug) ...{
System.out.println("ThreadPool.repool():重设中……");
}
// 优先级别判定
switch (repool.getPriority()) ...{
case Thread.MIN_PRIORITY:
this._idxThreads[PRIORITY_LOW].add(repool);
break;
case Thread.NORM_PRIORITY:
this._idxThreads[PRIORITY_NORMAL].add(repool);
break;
case Thread.MAX_PRIORITY:
this._idxThreads[PRIORITY_HIGH].add(repool);
break;
default:
throw new IllegalStateException("没有此种级别");
}
// 通知所有线程
notifyAll();
} else ...{
if (this._debug) ...{
System.out.println("ThreadPool.repool():注销中……");
}
repool.shutDown();
}
if(this._debug)...{
System.out.println("ThreadPool.repool():完成");
}
}
public void setDebug(boolean debug)...{
this._debug=debug;
}
public synchronized void shutDown()...{
this._shutdown=true;
if(this._debug)...{
System.out.println("ThreadPool.shutDown():关闭中……");
}
for(int index=0;index<=PRIORITY_NORMAL;index++)...{
List threads=this._idxThreads[index];
for(int threadIndex=0;threadIndex<threads.size();threadIndex++)...{
Pooled idleThread=(Pooled)threads.get(threadIndex);
idleThread.shutDown();
}
}
notifyAll();
}
/** *//**
* 以指定的优先级启动线程
* @param target
* @param priority
*/
public synchronized void start(Runnable target,int priority)...{
Pooled thread=null;
List idleList=this._idxThreads[priority];
int idleSize=idleList.size();
if(idleSize>0)...{
int lastIndex=idleSize-1;
thread=(Pooled)idleList.get(lastIndex);
idleList.remove(idleList);
thread.setTarget(target);
}else...{
this._threadCount++;
thread=new Pooled(target,"Pooled->"+this._threadCount,this);
switch(priority)...{
case PRIORITY_LOW:
thread.setPriority(Thread.MIN_PRIORITY);
break;
case PRIORITY_NORMAL:
thread.setPriority(Thread.NORM_PRIORITY);
break;
case PRIORITY_HIGH:
thread.setPriority(Thread.MAX_PRIORITY);
break;
default:
thread.setPriority(Thread.NORM_PRIORITY);
}
//启动
thread.start();
}
}
/** *//**
* 返回线程数量
*
* @return
*/
public int getThreadsCount() ...{
return this._threadCount;
}
}
Pooled.java:
package org.loon.framework.util.test;
/** *//**
* <p>
* Title: LoonFramework
* </p>
* <p>
* Description:
* </p>
* <p>
* Copyright: Copyright (c) 2007
* </p>
* <p>
* Company: LoonFramework
* </p>
*
* @author chenpeng
* @email：[email]ceponline@yahoo.com.cn[/email]
* @version 0.1
*/
public class Pooled extends Thread ...{
private ThreadPool _pool;
private Runnable _target;
private boolean _shutdown = false;
private boolean _idle = false;
public Pooled(Runnable target) ...{
super(target);
}
public Pooled(Runnable target, String name) ...{
super(target, name);
}
public Pooled(Runnable target, String name, ThreadPool pool) ...{
super(name);
this._pool = pool;
this._target = target;
}
public Pooled(String name) ...{
super(name);
}
public Pooled(ThreadGroup group, Runnable target) ...{
super(group, target);
}
public Pooled(ThreadGroup group, Runnable target, String name) ...{
super(group, target, name);
}
public Pooled(ThreadGroup group, String name) ...{
super(group, name);
}
public Runnable getTarget() ...{
return this._target;
}
public boolean isIdle() ...{
return this._idle;
}
public void run() ...{
while (!this._shutdown) ...{
this._idle = false;
if (this._target != null) ...{
this._target.run();
}
this._idle = true;
try ...{
this._pool.repool(this);
synchronized (this) ...{
wait();
}
} catch (InterruptedException ex) ...{
System.err.println(ex.getMessage());
}
this._idle = false;
}
}
public synchronized void setTarget(Runnable target) ...{
this._target = target;
notifyAll();
}
public synchronized void shutDown() ...{
this._shutdown = true;
notifyAll();
}
}
//测试用类：
package org.loon.framework.util.test;
/** *//**
* <p>Title: LoonFramework</p>
* <p>Description:线程池测试</p>
* <p>Copyright: Copyright (c) 2007</p>
* <p>Company: LoonFramework</p>
* @author chenpeng
* @email：[email]ceponline@yahoo.com.cn[/email]
* @version 0.1
*/
public class ThreadPoolTest ...{
private static Runnable createRunnable(final int id) ...{
return new Runnable() ...{
public void run() ...{
System.out.println("线程" + id + ",运行 ");
try ...{
Thread.sleep(1000);
}
catch (InterruptedException ex) ...{ }
System.out.println("线程" + id + ",结束");
}
};
}
public static void main(String[]args)...{
ThreadPool pool=ThreadPool.getInstance();
pool.setDebug(true);
for (int i=1; i<=10; i++) ...{
//根据数值，设定不同优先级
if(i%2==0)...{
pool.start(createRunnable(i), ThreadPool.PRIORITY_HIGH);
}else...{
pool.start(createRunnable(i), ThreadPool.PRIORITY_LOW);
}
}
System.out.println("线程池测试中……");
System.out.println("线程池线程总数:"+pool.getThreadsCount());
pool.shutDown();
}
}
转载于:https://blog.51cto.com/topstar/138505
JAVA线程池的简单实现及优先级设置相关推荐
- Java 线程池的简单使用及介绍
一.概述: 为什么要使用线程池?在实际开发过程中,如果不使用线程池,有可能会不加节制的去创建新的线程导致服务器cpu资源占满,无法相应其他请求.所以使用线程池就是为了控制开启多线程情况下,对其有开销控 ...
- java线程池的简单使用
线程池是预先创建的一种技术,线程池在还没有任务到来之前,创建一定数量的线程,放入空闲队列中,然后对这些资源进行复用,减少频繁的创建和销毁对象. JDK 1.5 版本以上提供了现成的线程池. java里 ...
- java 任务池_多线程的应用-异步任务线程池的简单实现
对于服务端的应用而言,经常会出现比如定时任务,或者任务的异步执行,熟悉Java开发的开发者,经常会使用Executors类,其提供了4种不同的线程池: newCachedThreadPool, ne ...
- java线程池概念_Java 线程池概念、原理、简单实现
线程池的思想概述 我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结東了,这样频繁创建线程就会大大降低系 ...
- 【Java 线程池 概念+深析】简单理解
加油,每天一篇博客,听一遍好运来 目录 1.简介 2.线程池 2.1 线程池的作用 2.2 为什么要用线程池 3.线程池的创建 3.1 线程池实例 3.1 四种线程池的使用 3.2 线程池实现原理 4 ...
- java线程池多线程优先级_Java线程优先级
java线程池多线程优先级 Priority of a thread describes how early it gets execution and selected by the thread ...
- 面试必问---Java线程池8大拒绝策略
前言 谈到java的线程池最熟悉的莫过于ExecutorService接口了,jdk1.5新增的java.util.concurrent包下的这个api,大大的简化了多线程代码的开发.而不论你用Fix ...
- 面试必备：Java线程池解析
点击上方"方志朋",选择"设为星标" 做积极的人,而不是积极废人 来源:https://juejin.im/post/5d1882b1f265da1ba84aa ...
- Java 线程池必知的8 大拒绝策略
点击上方蓝色"程序猿DD",选择"设为星标" 回复"资源"获取独家整理的学习资料! 来源 | kailing.pub/article/ind ...
最新文章
- kubelet配置cni插件_kubernetes网络插件对比分析（flannel、calico、weave）
- 遍历List 删除某条数据
- VB.NET完成一个功能增强的记事本
- 1352. 虫洞【难度: 中 / 枚举 判环】
- Linux下安装Redmine(项目管理软件)
- java获取子路径_Java中路径的获取
- linux内存段页,linux内存管理-段式和页式管理
- ApacheCN 深度学习译文集 20210112 更新
- matlab mex gcc 支持c99
- python万年历_python万年历
- 新浪微博技术架构分析
- java识别音高_如何找出音乐的音高
- Unity高德定位获取天气预报
- 《深度学习》/《Deep Learning》——深度学习圣经的读书笔记
- python有哪些细节描写_细节描写的句子有哪些
- 机器学习 2014斯坦福大学课程: 4-1 神经网络
- Codeforces--44A--Indian Summer
- word2003系统服务器,用Word?2003进行协同办公
- matlab中selector用法,MATLAB SIMULINK Bus Selector 总线选择
- springboot之获取yml对象