首页 - 技术 - java开源线程池(java线程池原理及实现)

java开源线程池(java线程池原理及实现)

2023-10-09 20:37

今天给大家分享java开源线程池的知识。还会讲解java线程池的原理和实现。如果它能够解决您现在面临的问题,请不要忘记关注本网站并立即开始!

本文内容列表:

  • www.gsm-guard.net线程池
  • 2.什么是java线程池?
  • www.gsm-guard.net实现通用线程池
  • www.gsm-guard.net线程池
  • 5、Java开发中常见的几种线程池
  • 6.几种开源Java Web容器线程池实现方法介绍

Java线程池

public ThreadPoolExecutor(int corePoolSize, int maxPoolSize, long keepAliveTime,

TimeUnit 单位,

BlockingQueueRunnable工作队列,

ThreadFactory 线程工厂,

RejectedExecutionHandler 处理程序)

什么是java线程池

请查看

正在寻找的信息:

多线程技术主要解决处理器单元内部多线程执行的问题。可以显着减少处理器单元的空闲时间,提高处理器单元的吞吐能力。

假设服务器完成一项任务所需时间为:T1

线程创建时间,T2

线程中执行任务的时间,T3

销毁线程时间。

如果:T1

+

T3

大得多

T2,可以使用线程池来提高服务器性能。

线程池包括以下四个基本组件:

1。线程池管理器(ThreadPool):用于创建和管理线程池,包括

创建线程池、销毁线程池、添加新任务;

2。工作线程(PoolWorker):线程池中的线程在没有任务时处于等待状态,可以循环执行任务;

3。任务接口(Task):每个任务必须实现的接口,以便工作线程调度任务的执行。主要规定任务的入口、任务执行后的收尾工作、任务的执行状态等;

4。任务队列(taskQueue):用于存储未处理的任务。提供缓冲机制。

线程池技术重点关注如何缩短或调整T1和T3时间,从而提高服务器程序的性能。它将T1和T3分别安排在服务器程序的启动和结束时间段或一些空闲时间段,这样服务器程序在处理客户请求时,就不会产生T1和T3的开销。

线程池不仅调整了T1和T3生成的时间段,而且还显着减少了创建的线程数量。看一个例子:

假设一台服务器每天处理 50,000 个请求,每个请求都需要一个单独的线程来完成。在线程池中,线程的数量一般是固定的,因此产生的线程总数不会超过线程池中的线程数量。如果服务器不使用线程池来处理这些请求,则线程总数将为 50,000。一般线程池大小远小于50000。因此,使用线程池的服务器程序就不会为了创建50000个而浪费时间在处理请求上,从而提高了效率。

Java实现通用线程池

线程池通俗的描述就是提前创建多个空闲线程,等到需要多个线程处理事务时,唤醒一些空闲线程来执行处理任务。这样就节省了频繁创建线程的时间,因为频繁创建线程很耗时。如果应用程序需要频繁处理大量并发事务,占用大量CPU资源,线程的不断创建和销毁往往会大大降低系统的效率。这就是线程池派上用场的地方

本文旨在使用Java语言编写一个通用的线程池。当需要使用线程池处理事务时,只需要按照指定规范封装事务处理对象,然后利用已有的线程池对象自动选择空闲线程,自动调用事务处理即可。该对象可用于动态修改线程池(修改当前线程数、最大线程数等)以下是实现代码

//ThreadTask java

封装polarman线程池;

/** *//**

*话题任务

* @作者 ryang

*

*/

公共接口 ThreadTask {

public void run();

}

//PooledThread java

封装polarman线程池;

import java util Collection;导入java util Vector;

/** *//**

*接受线程池管理的线程

* @作者 ryang

*

*/

公共类 PooledThread 扩展 Thread {

受保护的向量任务 = new Vector();

受保护的布尔运行 = false;

受保护的布尔值已停止 = false;

受保护的布尔值暂停 = false;

受保护的布尔值被杀死 = false;

私有ThreadPool池;

public PooledThread(ThreadPool pool) { 此池 = pool;

}

public void putTask(ThreadTask task) { 任务 add(task);

}

public void putTasks(ThreadTask[]tasks) { for(int i= ; itasks length; i++) 这个任务 add(tasks[i]);

}

public void putTasks(集合任务) { 这个任务 addAll(任务);

}

protected ThreadTask popTask() { if(tasks size() ) return (ThreadTask)tasks remove( );

其他

返回空;

}

public boolean isRunning() {

返回运行;

}

public void stopTasks() {

停止 = true;

}

public void stopTasksSync() {

stopTasks();

while(isRunning()) { 尝试{

睡觉( );

} catch (InterruptedException e) {

}

}

}

公共无效pauseTasks(){

暂停 = true;

}

公共无效pauseTasksSync(){

暂停任务();

while(isRunning()) { 尝试{

睡觉( );

} catch (InterruptedException e) {

}

}

}

public void Kill() { if(!running)

中断();

其他

被杀= true;

}

公共无效killSync(){

kill();

while(isAlive()) { 尝试{

睡觉( );

} catch (InterruptedException e) {

}

}

}

公共同步无效startTasks(){

运行 = true;

这个notify();

}

public synchronized void run() { try { while(true) { if(!running ||tasks size() == ) { pool notifyForIdleThread(); } //System out println(Thread currentThread() getId() + : 空闲 );这个等待(); }否则{

ThreadTask 任务;

while((task = popTask()) != null) { 任务 run();如果(停止){

停止= false;

if(任务大小()) { 任务清除(); System out println(Thread currentThread() getId() + : 任务停止 );

断裂;

}

}

if(暂停){

暂停 = false;

if(tasks size() ) { System out println(Thread currentThread() getId() + : 任务暂停 );

断裂;

}

}

}

运行 = false;

}

如果(被杀){

被杀=假;

断裂;

}

}

}catch(InterruptedException e) {

返回;

}

//系统输出 println(Thread currentThread() getId() + : Killed );

}

}

//线程池java

封装polarman线程池;

import java util Collection;导入 java util 迭代器;导入java util Vector;

/** *//**

*线程池

* @作者 ryang

*

*/

公共类 ThreadPool {

protected int maxPoolSize;

protected int initPoolSize;

受保护的 Vector 线程 = new Vector();

受保护的布尔值已初始化 = false;

protected boolean hasIdleThread = false;

public ThreadPool(int maxPoolSize int initPoolSize) { this maxPoolSize = maxPoolSize;这个 initPoolSize = initPoolSize;

}

public void init() {

初始化= true;

for(int i= ; iinitPoolSize; i++) {

PooledThread 线程 = new PooledThread(this);

线程start();线程添加(线程);

}

//系统 out println( 线程池初始化结束 线程数 = + 线程 size() + 最大线程数 = + maxPoolSize);

}

public void setMaxPoolSize(int maxPoolSize) { //系统 out println(重置最大线程数 最大线程数 = + maxPoolSize);这个 maxPoolSize = maxPoolSize;

if(maxPoolSize getPoolSize())

setPoolSize(maxPoolSize);

}

/** *//**

*重置当前线程数

* 如果需要杀死一个线程,该线程不会立即被杀死,而是会等待线程中的事务处理完成* 但是,该方法会立即将线程从线程池中移除,不会等待交易处理结束

* @参数大小

*/

public void setPoolSize(int size) { if(!initialized) {

initPoolSize = 大小;

返回;

}else if(size getPoolSize()) { for(int i=getPoolSize(); isize imaxPoolSize; i++) {

PooledThread 线程 = new PooledThread(this);

线程start();线程添加(线程);

}

}else if(size getPoolSize()) { while(getPoolSize() size) { PooledThread th = (PooledThread)threads remove( ); th Kill();

}

}

//系统 out println( 重新设置线程数 线程数= + 线程数 size());

}

public int getPoolSize() { return 线程大小();

}

protected void notifyForIdleThread() {

hasIdleThread = true;

}

protected boolean waitForIdleThread() {

hasIdleThread = false;

while(!hasIdleThread getPoolSize() = maxPoolSize) { 尝试 { 线程睡眠( ); } catch (InterruptedException e) {

返回 false;

}

}

返回true;

}

公共同步 PooledThread getIdleThread() { while(true) { for(Iterator itr=erator(); itr hasNext();) { PooledThread th = (PooledThread)itr next(); } if(!th isRunning())

返回;

}

if(getPoolSize() maxPoolSize) {

PooledThread 线程 = new PooledThread(this);

线程start();线程添加(线程);

回线;

}

//System out println( 线程池已满 等待 );

if(waitForIdleThread() == false)

返回空;

}

}

public void processTask(ThreadTask 任务) {

PooledThread th = getIdleThread();

if(th != null) { th putTask(task); th startTasks();

}

}

公共无效processTasksInSingleThread(ThreadTask []任务){

PooledThread th = getIdleThread();

if(th != null) { th putTasks(tasks); th startTasks();

}

}

public void processTasksInSingleThread(集合任务) {

PooledThread th = getIdleThread();

if(th != null) { th putTasks(tasks); th startTasks();

}

}

}

以下是线程池的测试程序

//ThreadPoolTest java

导入java io BufferedReader;导入java io IOException;导入java io InputStreamReader;

导入polarman线程池ThreadPool;导入 Polarman 线程池 ThreadTask;

公共类 ThreadPoolTest {

public static void main(String[] args) { System out println( quit 退出); System out println( 任务 A 启动任务 A 秒); System out println( size 设置当前线程池大小为); System out println( max 设置线程池中最大线程数为);系统输出 println();

最终 ThreadPool 池 = new ThreadPool( );池初始化();

线程 cmdThread = new Thread() { public void run() {

BufferedReader reader = new BufferedReader(new InputStreamReader(System in));

while(true) { 尝试 { String line = reader readLine();字符串words[] = line split( ); if(words[] equalsIgnoreCase( quit )) { 系统退出( ); }else if(words[ ] equalsIgnoreCase( size ) 单词长度 = ) { try { int size = Integer parseInt(words[ ]);池 setPoolSize(大小); }catch(异常 e){

}

}else if(words[ ] equalsIgnoreCase( max ) 单词长度 = ) { try { int max = Integer parseInt(words[ ]);池设置MaxPoolSize(最大); }catch(异常 e){

}

}else if(words[ ] equalsIgnoreCase( 任务 ) 单词长度 = ) { try { int timelen = Integer parseInt(words[ ]); SimpleTask 任务 = new SimpleTask(words[ ] timelen * );池进程任务(任务); }catch(异常 e){

}

}

} catch (IOException e) { e printStackTrace();

}

}

}

};

cmdThread start();

/**//*

for(int i= ; i ; i++){

SimpleTask 任务 = new SimpleTask( 任务 + i (i+ )* );池进程任务(任务);

}*/

}

}

SimpleTask 类实现 ThreadTask {

私有字符串任务名称;

private int timeLen;

public SimpleTask(String taskName int timeLen) { 此任务名称 = 任务名称;这次Len = timeLen;

}

public void run() { System out println(Thread currentThread() getId() +

: 开始任务 + 任务名称 + );

尝试 { 线程睡眠(timeLen); } catch (InterruptedException e) {

}

系统输出 println(Thread currentThread() getId() +

: 结束任务 + 任务名称 + );

}

}

使用这个线程池非常简单。下面两行代码初始化线程池

ThreadPool 池 = new ThreadPool( );池初始化();

待处理的任务只需实现ThreadTask接口即可(如测试代码中的SimpleTask)。该接口只有一个方法run()

只需两行代码即可调用

lixixinzhi/文章/程序/Java/hx/201311/27203

Java线程池

你所说的本身就是线程池的功能。你可以看一下ThreadPoolExecutor类。可以实现你说的

java开发中常见的几种线程池

一:newCachedThreadPool

(1) 对于缓存类型池,首先检查池中是否有先前创建的线程。如果有,请重复使用它们。如果没有,则创建一个新线程并将其添加到池中;

(2) 缓存池通常用于执行一些生命周期较短的异步任务;因此,在一些面向连接的守护进程服务器中使用得不多;

(3) 可重用的线程必须是池中处于超时IDLE状态的线程。默认超时时间为 60 秒。如果超过此 IDLE 时间,线程实例将被终止并从池中删除。

(4) 注意,放置在CachedThreadPool中的线程不必担心它的结束。如果处于非活动状态超过TIMEOUT,则会自动终止

二:newFixedThreadPool

(1) newFixedThreadPool 与cacheThreadPool 类似。可以重复使用,但不能随时创建新线程

(2)其独特性:在任意时间点,最多只能有固定数量的活动线程。这时如果有新的线程想要建立,只能放到另一个队列中,等到当前线程中的一个线程终止时,直接从池中移除

(3)与cacheThreadPool不同,FixedThreadPool没有IDLE机制(可能有,但由于文档没有提到,所以肯定很长,类似于依赖上层TCP或UDP的IDLE机制),所以FixedThreadPool主要是针对一些非常稳定且非常固定的常规并发线程,多用于服务器

(4)从方法源码来看,缓存池和固定池调用的是同一个底层池,但参数不同:

固定池有固定数量的线程并且是0秒IDLE(无IDLE)

缓存池线程数支持0-Integer.MAX_VALUE(显然不考虑主机的资源容量),60秒IDLE

三:ScheduledThreadPool

(1)调度线程池

(2) 该池中的线程可以按照调度顺序延迟执行,也可以周期性执行

四:SingleThreadExecutor

(1)单例线程,池中任何时候只能有一个线程

(2)使用与缓存池和固定池相同的底层池,但线程数为1-1,0秒IDLE(无IDLE)

几种开源Java Web容器线程池实现方法介绍

其中Resin在V3.0之后需要购买才能用于商业用途,而另外两个则是纯开源的。最新的二进制包和源代码可以分别从他们的网站下载。

作为Web容器,需要承受大流量的访问,能够同时响应不同用户的请求,并在恶劣的环境下保持较高的稳定性和鲁棒性。在HTTP服务器领域,ApacheHTTPD是最高效、最稳定的,但它只能处理静态页面请求。如果需要支持动态页面请求,则必须安装相应的插件。例如,mod_perl可以处理Perl脚本,mod_python可以处理Python脚本。

上面介绍的三个Web容器都是用Java编写的HTTP服务器。当然,它们可以嵌入到Apache中并独立使用。分析他们处理客户请求的方法,有助于理解Java多线程和线程池的实现方法,为设计强大的多线程服务器打下坚实的基础。

Tomcat是应用最广泛的Java Web容器,功能强大,可扩展性强。为了提高响应速度和效率,最新版本的Tomcat(5.5.17)使用Apache Portable Runtime(APR)作为底层。 APR包含了Socket、缓冲池等技术,性能也得到了提升。 APR也是Apache HTTPD的底层。可以想象,ASF(Apache软件基金会)的成员即使使用不同的开发语言,仍然可以在很多情况下实现互补。

Tomcat的线程池位于tomcat-util.jar文件中,包含两种线程池解决方案。方案一:使用APR的Pool技术和JNI;选项 2:使用 Java 实现的 ThreadPool。这里介绍的是第二种。如果想了解APR的Pool技术,可以查看APR的源码。

ThreadPool默认创建5个线程,存储在200维的线程数组中。这些线程在创建时启动。当然,没有请求的时候,都是处理等待状态(实际上是一个while循环,不停的等待notify)。如果有请求,就会唤醒空闲线程来执行用户的请求。

具体请求流程为:服务启动时,创建一维线程数组(maxThread=200),并创建空闲线程(minSpareThreads=5)随时等待用户请求。当有用户请求时,调用threadpool.runIt(ThreadPoolRunnable)方法并将要执行的实例传递给ThreadPool。用户需要执行的实例必须实现ThreadPoolRunnable接口。 ThreadPool首先寻找空闲线程,如果有则使用它来运行ThreadPoolRunnable;如果没有空闲线程且不超过maxThreads,则立即创建minSpareThreads个空闲线程;如果超过 maxThreads,则等待空闲线程。简而言之,找到一个空闲线程,以便可以使用它来执行实例。一旦找到,就从线程数组中删除该线程。然后唤醒已经找到的空闲线程,并用它来运行执行实例(ThreadPoolRunnable)。 ThreadPoolRunnable运行完毕后,该线程会作为空闲线程放回线程数组中,以供后续使用。

由此可以看出,Tomcat的线程池实现比较简单,www.gsm-guard.net只有840行代码。使用一维数组保存空闲线程,每次以较小的速度(5)创建空闲线程并放入线程池中。使用时从数组中取出空闲线程,使用完毕后将其放回线程池。

java开源线程池和java线程池的原理和实现介绍到此结束。不知道你找到你需要的信息了吗?如果您想了解更多相关信息,请记得添加书签并关注本网站。