- 浏览: 301393 次
- 性别:
- 来自: 上海
文章分类
- 全部博客 (298)
- Tomcat (3)
- ZooKeeper (1)
- Maven (11)
- opensource (1)
- DataBase (5)
- UML (8)
- linux (87)
- Java (32)
- 算法 (3)
- Redis (1)
- HBase (2)
- 产品 (1)
- 模板引擎 (1)
- Eclipse (10)
- JUnit (5)
- Log4j (8)
- XML (2)
- JSON (1)
- SpringMVC (23)
- Spring (24)
- TCP/IP (4)
- Windows (10)
- Web Service (1)
- 源码版本管理 (1)
- Word (1)
- Test (1)
- Mybatis (7)
- CentOS (2)
- 多线程 (2)
- Web (7)
- Servlet (3)
- JavaWeb (4)
- MySQL (7)
- 汇编语言 (2)
- linux Shell (4)
- GIT (4)
- Python (1)
- 并发 (4)
- 编程通用 (1)
- JavaScript (1)
- 异常 (3)
- 自动化部署 (1)
- 大数据 (1)
- hive (2)
- 文本编辑器 (2)
- MINA (0)
- intellij IDEA (9)
- masm (0)
- blockchain (1)
- docker (2)
- IDEA (0)
- GO (3)
- nginx (1)
- springBoot (3)
- Websocket (2)
- macOS (1)
最新评论
-
woodding2008:
ss –pl 可以查看监听方式启动的端口以及pid
根据端口查PID,根据PID查进程名称 -
masuweng:
恩很试用,也很常用。
linux 常用命令
from:
http://zy116494718.iteye.com/blog/1725365
一、简介
1)线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
参数讲解:
corePoolSize: 线程池维护线程的最少数量
maximumPoolSize:线程池维护线程的最大数量
keepAliveTime: 线程池维护线程所允许的空闲时间
unit: 线程池维护线程所允许的空闲时间的单位
workQueue: 线程池所使用的缓冲队列
handler: 线程池对拒绝任务的处理策略
unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性:
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常用的是:java.util.concurrent.ArrayBlockingQueue
handler有四个选择:
ThreadPoolExecutor.AbortPolicy()
直接抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务,他会自动重复调用execute()方法,交由调用者线程来执行此Runnable任务
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务
2)一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法。
当一个任务通过execute(Runnable)方法欲添加到线程池时 :
如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。
也就是:处理任务的优先级为:
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
二、多线程例子
Java代码 收藏代码
package demo;
import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool2
{
private static int produceTaskSleepTime = 2;
private static int produceTaskMaxNumber = 10;
public static void main(String[] args)
{
// 构造一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 1; i <= produceTaskMaxNumber; i++)
{
try
{
// 产生一个任务,并将其加入到线程池
String task = "task@ " + i;
System.out.println("put " + task);
threadPool.execute(new ThreadPoolTask(task));
// 便于观察,等待一段时间
Thread.sleep(produceTaskSleepTime);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
/**
* 线程池执行的任务
*/
class ThreadPoolTask implements Runnable, Serializable
{
private static final long serialVersionUID = 0;
private static int consumeTaskSleepTime = 2000;
// 保存任务所需要的数据
private Object threadPoolTaskData;
ThreadPoolTask(Object tasks)
{
this.threadPoolTaskData = tasks;
}
public void run()
{
// 处理一个任务,这里的处理方式太简单了,仅仅是一个打印语句
System.out.println(Thread.currentThread().getName());
System.out.println("start .." + threadPoolTaskData);
try
{
// //便于观察,等待一段时间
Thread.sleep(consumeTaskSleepTime);
}
catch (Exception e)
{
e.printStackTrace();
}
threadPoolTaskData = null;
}
public Object getTask()
{
return this.threadPoolTaskData;
}
}
说明:
1、在这段程序中,一个任务就是一个Runnable类型的对象,也就是一个ThreadPoolTask类型的对象。
2、一般来说任务除了处理方式外,还需要处理的数据,处理的数据通过构造方法传给任务。
3、在这段程序中,main()方法相当于一个残忍的领导,他派发出许多任务,丢给一个叫 threadPool的任劳任怨的小组来做。
这个小组里面队员至少有两个,如果他们两个忙不过来,任务就被放到任务列表里面。
如果积压的任务过多,多到任务列表都装不下(超过3个)的时候,就雇佣新的队员来帮忙。但是基于成本的考虑,不能雇佣太多的队员,至多只能雇佣 4个。
如果四个队员都在忙时,再有新的任务,这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发,直到接受这个任务为止(更残忍!呵呵)。
因为队员工作是需要成本的,如果工作很闲,闲到 3SECONDS都没有新的任务了,那么有的队员就会被解雇了,但是,为了小组的正常运转,即使工作再闲,小组的队员也不能少于两个。
4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制,改变这两个值就可以观察不同速率下程序的工作情况。
5、通过调整4中所指的数据,再加上调整任务丢弃策略,换上其他三种策略,就可以看出不同策略下的不同处理方式。
三、一个用队列处理线程池例子
Java代码 收藏代码
package demo;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest
{
private static int queueDeep = 4;
public void createThreadPool()
{
/*
* 创建线程池,最小线程数为2,最大线程数为4,线程池维护线程的空闲时间为3秒,
* 使用队列深度为4的有界队列,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,
* 然后重试执行程序(如果再次失败,则重复此过程),里面已经根据队列深度对任务加载进行了控制。
*/
ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep),
new ThreadPoolExecutor.DiscardOldestPolicy()); //这里采取的是抛弃旧的任务
// 向线程池中添加 10 个任务
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(1);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
while (getQueueSize(tpe.getQueue()) >= queueDeep)
{
System.out.println("队列已满,等3秒再添加任务");
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
TaskThreadPool ttp = new TaskThreadPool(i);
System.out.println("put i:" + i);
tpe.execute(ttp);
}
tpe.shutdown();
}
private synchronized int getQueueSize(Queue queue)
{
return queue.size();
}
public static void main(String[] args)
{
ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
test.createThreadPool();
}
class TaskThreadPool implements Runnable
{
private int index;
public TaskThreadPool(int index)
{
this.index = index;
}
public void run()
{
System.out.println(Thread.currentThread() + " index:" + index);
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
说明:
这里执行的结果为:
put i:0
Thread[pool-1-thread-1,5,main] index:0
put i:1
Thread[pool-1-thread-2,5,main] index:1
put i:2
put i:3
put i:4
put i:5
队列已满,等3秒再添加任务
Thread[pool-1-thread-1,5,main] index:2
Thread[pool-1-thread-2,5,main] index:3
put i:6
put i:7
队列已满,等3秒再添加任务
Thread[pool-1-thread-1,5,main] index:4
Thread[pool-1-thread-2,5,main] index:5
put i:8
put i:9
Thread[pool-1-thread-1,5,main] index:6
Thread[pool-1-thread-2,5,main] index:7
Thread[pool-1-thread-1,5,main] index:8
Thread[pool-1-thread-2,5,main] index:9
ps:这里是当队列已满时线程就一直等待了,不会再新创建线程,所以一直就只有1和2两个线程来执行。
如果把
Java代码 收藏代码
while (getQueueSize(tpe.getQueue()) >= queueDeep){}
这一段去掉,那么执行结果为:
put i:0
Thread[pool-1-thread-1,5,main] index:0
put i:1
Thread[pool-1-thread-2,5,main] index:1
put i:2
put i:3
put i:4
put i:5
put i:6
Thread[pool-1-thread-3,5,main] index:6
put i:7
Thread[pool-1-thread-4,5,main] index:7
put i:8
put i:9
Thread[pool-1-thread-1,5,main] index:4
Thread[pool-1-thread-2,5,main] index:5
Thread[pool-1-thread-3,5,main] index:8
Thread[pool-1-thread-4,5,main] index:9
ps:这个执行顺序是0,1两个任务先进来,分别由线程1,2来执行,然后2,-5进来,队列满,6任务进来,因为队列已满,且1,2线程还未执行完,没有可用的线程,所以创建新的线程来运行6。7任务同理。然后8任务进来,队列已满,且1,2,3,4线程未执行完,线程数又等于了最多4个线程的限制,这时看线程池的执行策略为DiscardOldestPolicy,就是抛弃旧的任务,故开始进队列的2任务被抛弃,3任务同理,8,9任务进入队列,然后这时1-4线程已经执行完自己的任务,开始执行队列中的4,5,8,9
如果更改执行策略,那么相应的结果也会不一样,如果不希望有任务被抛弃,那么可以采用CallerRunsPolicy()策略。
http://zy116494718.iteye.com/blog/1725365
一、简介
1)线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
参数讲解:
corePoolSize: 线程池维护线程的最少数量
maximumPoolSize:线程池维护线程的最大数量
keepAliveTime: 线程池维护线程所允许的空闲时间
unit: 线程池维护线程所允许的空闲时间的单位
workQueue: 线程池所使用的缓冲队列
handler: 线程池对拒绝任务的处理策略
unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性:
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常用的是:java.util.concurrent.ArrayBlockingQueue
handler有四个选择:
ThreadPoolExecutor.AbortPolicy()
直接抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务,他会自动重复调用execute()方法,交由调用者线程来执行此Runnable任务
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务
2)一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法。
当一个任务通过execute(Runnable)方法欲添加到线程池时 :
如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。
也就是:处理任务的优先级为:
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
二、多线程例子
Java代码 收藏代码
package demo;
import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool2
{
private static int produceTaskSleepTime = 2;
private static int produceTaskMaxNumber = 10;
public static void main(String[] args)
{
// 构造一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 1; i <= produceTaskMaxNumber; i++)
{
try
{
// 产生一个任务,并将其加入到线程池
String task = "task@ " + i;
System.out.println("put " + task);
threadPool.execute(new ThreadPoolTask(task));
// 便于观察,等待一段时间
Thread.sleep(produceTaskSleepTime);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
/**
* 线程池执行的任务
*/
class ThreadPoolTask implements Runnable, Serializable
{
private static final long serialVersionUID = 0;
private static int consumeTaskSleepTime = 2000;
// 保存任务所需要的数据
private Object threadPoolTaskData;
ThreadPoolTask(Object tasks)
{
this.threadPoolTaskData = tasks;
}
public void run()
{
// 处理一个任务,这里的处理方式太简单了,仅仅是一个打印语句
System.out.println(Thread.currentThread().getName());
System.out.println("start .." + threadPoolTaskData);
try
{
// //便于观察,等待一段时间
Thread.sleep(consumeTaskSleepTime);
}
catch (Exception e)
{
e.printStackTrace();
}
threadPoolTaskData = null;
}
public Object getTask()
{
return this.threadPoolTaskData;
}
}
说明:
1、在这段程序中,一个任务就是一个Runnable类型的对象,也就是一个ThreadPoolTask类型的对象。
2、一般来说任务除了处理方式外,还需要处理的数据,处理的数据通过构造方法传给任务。
3、在这段程序中,main()方法相当于一个残忍的领导,他派发出许多任务,丢给一个叫 threadPool的任劳任怨的小组来做。
这个小组里面队员至少有两个,如果他们两个忙不过来,任务就被放到任务列表里面。
如果积压的任务过多,多到任务列表都装不下(超过3个)的时候,就雇佣新的队员来帮忙。但是基于成本的考虑,不能雇佣太多的队员,至多只能雇佣 4个。
如果四个队员都在忙时,再有新的任务,这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发,直到接受这个任务为止(更残忍!呵呵)。
因为队员工作是需要成本的,如果工作很闲,闲到 3SECONDS都没有新的任务了,那么有的队员就会被解雇了,但是,为了小组的正常运转,即使工作再闲,小组的队员也不能少于两个。
4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制,改变这两个值就可以观察不同速率下程序的工作情况。
5、通过调整4中所指的数据,再加上调整任务丢弃策略,换上其他三种策略,就可以看出不同策略下的不同处理方式。
三、一个用队列处理线程池例子
Java代码 收藏代码
package demo;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest
{
private static int queueDeep = 4;
public void createThreadPool()
{
/*
* 创建线程池,最小线程数为2,最大线程数为4,线程池维护线程的空闲时间为3秒,
* 使用队列深度为4的有界队列,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,
* 然后重试执行程序(如果再次失败,则重复此过程),里面已经根据队列深度对任务加载进行了控制。
*/
ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep),
new ThreadPoolExecutor.DiscardOldestPolicy()); //这里采取的是抛弃旧的任务
// 向线程池中添加 10 个任务
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(1);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
while (getQueueSize(tpe.getQueue()) >= queueDeep)
{
System.out.println("队列已满,等3秒再添加任务");
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
TaskThreadPool ttp = new TaskThreadPool(i);
System.out.println("put i:" + i);
tpe.execute(ttp);
}
tpe.shutdown();
}
private synchronized int getQueueSize(Queue queue)
{
return queue.size();
}
public static void main(String[] args)
{
ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
test.createThreadPool();
}
class TaskThreadPool implements Runnable
{
private int index;
public TaskThreadPool(int index)
{
this.index = index;
}
public void run()
{
System.out.println(Thread.currentThread() + " index:" + index);
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
说明:
这里执行的结果为:
put i:0
Thread[pool-1-thread-1,5,main] index:0
put i:1
Thread[pool-1-thread-2,5,main] index:1
put i:2
put i:3
put i:4
put i:5
队列已满,等3秒再添加任务
Thread[pool-1-thread-1,5,main] index:2
Thread[pool-1-thread-2,5,main] index:3
put i:6
put i:7
队列已满,等3秒再添加任务
Thread[pool-1-thread-1,5,main] index:4
Thread[pool-1-thread-2,5,main] index:5
put i:8
put i:9
Thread[pool-1-thread-1,5,main] index:6
Thread[pool-1-thread-2,5,main] index:7
Thread[pool-1-thread-1,5,main] index:8
Thread[pool-1-thread-2,5,main] index:9
ps:这里是当队列已满时线程就一直等待了,不会再新创建线程,所以一直就只有1和2两个线程来执行。
如果把
Java代码 收藏代码
while (getQueueSize(tpe.getQueue()) >= queueDeep){}
这一段去掉,那么执行结果为:
put i:0
Thread[pool-1-thread-1,5,main] index:0
put i:1
Thread[pool-1-thread-2,5,main] index:1
put i:2
put i:3
put i:4
put i:5
put i:6
Thread[pool-1-thread-3,5,main] index:6
put i:7
Thread[pool-1-thread-4,5,main] index:7
put i:8
put i:9
Thread[pool-1-thread-1,5,main] index:4
Thread[pool-1-thread-2,5,main] index:5
Thread[pool-1-thread-3,5,main] index:8
Thread[pool-1-thread-4,5,main] index:9
ps:这个执行顺序是0,1两个任务先进来,分别由线程1,2来执行,然后2,-5进来,队列满,6任务进来,因为队列已满,且1,2线程还未执行完,没有可用的线程,所以创建新的线程来运行6。7任务同理。然后8任务进来,队列已满,且1,2,3,4线程未执行完,线程数又等于了最多4个线程的限制,这时看线程池的执行策略为DiscardOldestPolicy,就是抛弃旧的任务,故开始进队列的2任务被抛弃,3任务同理,8,9任务进入队列,然后这时1-4线程已经执行完自己的任务,开始执行队列中的4,5,8,9
如果更改执行策略,那么相应的结果也会不一样,如果不希望有任务被抛弃,那么可以采用CallerRunsPolicy()策略。
发表评论
-
彻底理解ThreadLocal
2019-06-24 21:14 323https://www.cnblogs.com/xzwblog ... -
java异步任务处理
2018-09-03 11:35 820from: https://www.cnblogs.com/ ... -
Java多线程编程(3)-对象共享
2018-01-12 17:31 3661 可见性 (1)失效数据 (2)非原子的64位操作 (3)加 ... -
Java多线程编程 - 前言
2018-01-01 17:56 0记录自己学习多线程点点滴滴。 很多书籍写的理论性比较多,重复 ... -
深入理解并发之CompareAndSet(CAS)
2017-12-30 21:55 564http://flychao88.iteye.com/blog ... -
Java中堆内存和栈内存详解
2017-12-24 11:12 0https://www.cnblogs.com/iliuyue ... -
查看class文件的jdk版本
2017-11-14 22:34 632准备好要查看的class文件,本例使用Tools ... -
mave打包编译java生成的jdk版本 / Maven项目在刷新/导入项目时jdk版本过低的解决方案
2017-08-31 21:23 10651 pom.xml 决定代码版本 <plugin> ... -
Java安全框架—Shiro Apache 的孵化器项目Shiro其前身是JSecurity
2017-01-02 23:34 407from http://blog.csdn.net/pete ... -
Lombok 安装、入门 - 消除冗长的 java 代码
2016-12-26 16:30 419from: http://www.blogjava.net/f ... -
线程池系列三:结合线程池实现Socket
2016-12-23 21:03 990from : http://zy116494718.itey ... -
线程池系列一:线程池作用及Executors方法讲解
2016-12-23 21:01 1254from : http://zy116494718.i ... -
applicationContext.xml 和 springmvc-servlet.xml 配置文件加载顺序
2016-12-20 15:32 788applicationContext.xml是随Context ... -
linux下分析Java程序内存汇总
2016-12-05 08:56 860http://blog.csdn.net/zlzlei/ar ... -
JVM:查看java内存情况命令
2016-12-05 08:54 1177https://my.oschina.net/u/138514 ... -
使用JMAP dump及分析dump文件
2016-12-05 08:50 1569from http://www.cnblogs.com/ ... -
Netty
2016-11-18 09:48 478Netty是由JBOSS提供的一个java开源框架。Netty ... -
常见Java Web 容器比较 (tomcat、 jboss 、resin、 weblogic、 websphere、 glassfish)
2016-11-08 14:55 2717web 容器比较 tomcat jboss resin web ... -
Spring加载resource时classpath*:与classpath:的区别
2016-10-19 10:14 975from : http://blog.csdn.net/ ... -
Java web工程web.xml 配置中classpath: 与classpath*:的区别
2016-10-19 10:13 430首先 classpath是指 WEB-INF文件夹下的clas ...
相关推荐
Java线程池是一种高效管理线程资源的工具,它的核心组件是`ThreadPoolExecutor`类,它在Java的`java.util.concurrent`包中。线程池的使用能够显著提高应用程序的性能和响应速度,同时减少系统资源的浪费。下面将详细...
本文将详细讲解如何使用Java中的`ThreadPoolExecutor`来抓取论坛帖子列表,结合源码分析和实用工具的应用。 首先,我们要了解线程池的基本原理。线程池是由一组预先创建的线程组成的,这些线程可以复用,而不是每次...
Java线程池的实现主要有`ThreadPoolExecutor`类,它提供了丰富的构造参数来定制线程池的行为: - `corePoolSize`:线程池的基本大小,即当线程池创建后和运行过程中,即使没有任务,也会保持这个数量的线程存活。 -...
在 Spring Boot 中使用 Java 线程池 ExecutorService 的讲解 Spring Boot 作为一个流行的 Java 框架,提供了许多便捷的功能来帮助开发者快速构建应用程序。其中之一就是使用 Java 线程池 ExecutorService 来管理...
在Java中,`java.util.concurrent`包提供了`ExecutorService`接口及其实现类,如`ThreadPoolExecutor`,用于创建线程池。创建一个Socket线程池的基本步骤如下: 1. **初始化线程池**:通过`ThreadPoolExecutor`构造...
通过ThreadPoolExecutor,你可以理解如何设置核心线程数、最大线程数、队列容量等参数,以及如何提交任务和关闭线程池。 5. **Socket与多线程结合**:在实际应用中,Socket通信常与多线程结合,用于处理多个客户端...
本文主要讲解了Java中的阻塞队列、线程池以及File类的相关知识,并涉及到了递归的概念。阻塞队列是并发编程中的一种重要工具,它在多线程环境下的生产者-消费者模型中起到关键作用。线程池则是为了优化线程管理,...
通过ThreadPoolExecutor,我们可以自定义线程池的核心线程数、最大线程数、线程空闲时间、任务队列等参数,从而优化线程管理。使用submit()方法可以将任务提交到线程池,线程池会根据策略决定何时执行这些任务。 ...
内容概要:本篇文章深入探讨了Java中多线程管理的一个关键...阅读建议:文中不仅有理论讲解还有实操案例,因此推荐读者一边阅读相关章节,一边亲手实验每一步的操作步骤,这样才能深刻理解线程池的设计思路和使用技巧。
6. **线程池**:深入讲解ExecutorService和ThreadPoolExecutor,以及如何合理配置线程池,以优化系统资源的使用和任务调度。 7. **原子操作与无锁编程**:介绍了java.util.concurrent.atomic包下的原子类,如...
Python中实现线程池主要有两种方式:一是使用第三方库`threadpool`,二是使用Python 3引入的标准库`concurrent.futures.ThreadPoolExecutor`。 1. **threadpool方式**: 首先需要通过`pip install threadpool`安装...
其中,`ThreadPoolExecutor`类是线程池的核心,它可以用于创建和管理一组线程,以执行一系列的任务。下面将详细讲解如何使用`ThreadPoolExecutor`以及其优点。 ### 使用ThreadPoolExecutor 1. **创建线程池** ...
"Android异步加载图像小结(含线程池,缓存方法)"这个文档详细讲解了如何在Android环境中高效、异步地加载图片,同时利用线程池和缓存策略优化性能。以下是对这些知识点的详细说明: 1. **异步加载**: - 异步...
6. **线程池**:Java提供`ExecutorService`和`ThreadPoolExecutor`来管理和控制线程,线程池可以有效地复用线程,减少创建和销毁线程的开销,提高系统效率。常用的接口有`Executors`,可以创建固定大小、单线程、...
1. **线程池(ThreadPoolExecutor)**:线程池是管理线程的利器,通过预先创建一定数量的线程,避免频繁地创建和销毁线程带来的开销。ThreadPoolExecutor提供了灵活的配置选项,如核心线程数、最大线程数、工作队列...
- **线程池**:ThreadPoolExecutor管理线程,提高系统效率。 8. **反射API** - **Class类**:获取类的信息,如类名、方法、字段等。 - **newInstance()**:动态创建类的实例。 - **Method和Constructor**:用于...
4. **线程池**:深入剖析了Executor框架,包括ThreadPoolExecutor的配置和使用,以及如何通过定制线程池来优化性能和资源管理。 5. **并发设计模式**:介绍了一些经典的并发设计模式,如生产者消费者模型、工作窃取...
- **线程池**:详细介绍如何使用Executor框架创建线程池,以及ThreadPoolExecutor的具体配置方法。 - **并发集合**:介绍ConcurrentHashMap、CopyOnWriteArrayList等并发集合的使用方法及适用场景。 - **原子变量**...
6. 线程池:ExecutorService和ThreadPoolExecutor,以及线程池的管理和优化。 第十八章:网络编程 1. Socket编程:基于TCP/IP的网络通信,客户端和服务器端的建立连接、发送数据和关闭连接。 2. ServerSocket和...
- **线程池**:讲解ExecutorService、ThreadPoolExecutor、ScheduledExecutorService的使用和配置,以及线程池的优化策略。 5. **并发异常处理** - **线程中断**:讨论中断机制,如何优雅地停止线程。 - **死锁*...