详解Java中的线程池

时间:2022-09-21 13:29:35

1.简介

使用线程池可以避免线程的频繁创建以及销毁。

java中提供的用于实现线程池的api:

详解Java中的线程池

executor、executorservice、abstractexecutorservice、threadpoolexecutor、forkjoinpool都位于java.util.concurrent包下。

*threadpoolexecutor、forkjoinpool为线程池的实现类。

2.executor

?
1
2
3
4
5
6
7
8
public interface executor {
 
  /**
   * 向线程池提交一个任务,交由线程池去执行
   */
  void execute(runnable command);
 
}

*该接口声明了execute(runnable command)方法,负责向线程池中提交一个任务。

3.executorservice接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public interface executorservice extends executor {
 
  /**
   * 关闭线程池(等待队列中的任务被执行完毕)
   */
  void shutdown();
 
  /**
   * 立刻关闭线程池(不执行队列中的任务,并尝试中断当前执行的任务)
   */
  list<runnable> shutdownnow();
 
  /**
   * 判断线程池是否处于shutdown状态.
   */
  boolean isshutdown();
 
  /**
   * 判断线程池是否处于terminated状态.
   */
  boolean isterminated();
 
  /**
   * 若在指定时间内线程池处于terminated状态则立即返回true,否则超过时间后仍未为terminated状态则返回false.
   */
  boolean awaittermination(long timeout, timeunit unit) throws interruptedexception;
 
  /**
   * 向线程池提交一个任务并返回包含指定类型的future(根据callable的泛型)
   */
  <t> future<t> submit(callable<t> task);
 
  /**
   * 向线程池提交一个任务并指定任务执行结果的类型,返回包含指定类型的future.
   */
  <t> future<t> submit(runnable task, t result);
 
  /**
   * 向线程池提交一个任务并返回未知类型的future.
   */
  future<?> submit(runnable task);
 
  /**
   * 向线程池提交多个任务并返回指定类型的future列表.
   */
  <t> list<future<t>> invokeall(collection<? extends callable<t>> tasks) throws interruptedexception;
 
  /**
   * 向线程池提交多个任务并返回指定类型的future列表,如果在指定时间内没有执行完毕则直接返回.
   */
  <t> list<future<t>> invokeall(collection<? extends callable<t>> tasks, long timeout, timeunit unit) throws interruptedexception;
   
  /**
   * 向线程池提交多个任务,当任意一个任务执行完毕后返回指定类型的future.
   */
  <t> t invokeany(collection<? extends callable<t>> tasks) throws interruptedexception, executionexception;
 
  /**
   * 向线程池提交多个任务,在指定时间内,当任意一个任务执行完毕后返回指定类型的future,若超时则抛出异常.
   */
  <t> t invokeany(collection<? extends callable<t>> tasks, long timeout, timeunit unit) throws interruptedexception, executionexception, timeoutexception;
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public interface future<v> {
 
  /**
   * 中断任务的执行
   */
  boolean cancel(boolean mayinterruptifrunning);
 
  /**
   * 判断任务是否中断成功
   */
  boolean iscancelled();
 
  /**
   * 判断任务是否执行完成
   */
  boolean isdone();
  
  /**
   * 获取任务的执行结果直到任务执行完毕(阻塞线程)
   */
  v get() throws interruptedexception, executionexception;
 
  /**
   * 获取任务的执行结果,若在指定时间内任务仍然没有执行完毕则抛出timeoutexception
   */
  v get(long timeout, timeunit unit) throws interruptedexception, executionexception, timeoutexception;
}

*execute()方法不能获取任务的执行结果,而submit()方法能够根据返回的future实例获取任务的执行结果。

4.threadpoolexecutor

corepoolsize:线程池中核心线程的数量。

maximumpoolsize:线程池中最大线程数。

keepalivetime:线程的空闲时间。

unit:修饰线程空闲时间的单位。

workqueue:任务队列。

threadfactory:线程工厂,用于创建线程。

handler:当队列已满且当前线程数已达到所允许的最大值时的处理策略。

*线程池中的线程包括核心线程以及普通线程,核心线程一旦创建后直到线程池被关闭前都就不会被销毁,而普通线程会因为到达空闲时间而被销毁。

构造方法:

?
1
2
3
4
5
6
7
public threadpoolexecutor(int corepoolsize,
             int maximumpoolsize,
             long keepalivetime,
             timeunit unit,
             blockingqueue<runnable> workqueue,
             threadfactory threadfactory,
             rejectedexecutionhandler handler)

blockingqueue的类型 

 blockingqueue提供了arrayblockingqueue、linkedblockingqueue、synchronousqueue等实现类。

1.arrayblockingqueue:使用顺序表的结构进行存储,在使用时需要指定其长度,支持公平锁/非公平锁进行操作。

2.linkedblockingqueue:使用链表的结构进行存储,在使用时不需要指定其长度,队列的最大长度为integer.max_value。

3.synchronousqueue:一个不存储元素的队列,每一个put操作必须等待take操作,否则不能添加元素,支持公平锁和非公平锁。

 *这些实现类在进行入队和出队操作时都会进行加锁,以保证在多线程并发访问时数据的安全性。

队列已满且线程数已达到所允许的最大值时的处理策略

rejectedexecutionhandler提供了abortpolicy、discardpolicy、discardolderstpolicy、callerrunspolicy四个策略,这四个策略都是threadpoolexecutor的静态内部类。

1.abortpolicy:放弃任务并抛出rejectedexecutionexception异常。

2.discardpolicy:放弃任务但不抛出异常。

3.discardolderstpolicy: 放弃队头中的任务,然后重新尝试执行新任务。

4.callerrunspolicy: 由调用线程来处理该任务。

线程池的状态

?
1
2
3
4
5
private static final int running  = -1
private static final int shutdown  = 0
private static final int stop    = 1
private static final int tidying  = 2
private static final int terminated = 3

1.runing:线程池处于运行状态,此时可以接受新的任务请求,并且执行队列中的任务。

2.shutdown:线程池处于关闭状态,此时不接受新的任务请求,但会继续执行队列中的任务。

3.stop:线程池处于禁用状态,此时不接受新的任务请求,并且不会执行队列中的任务。

4.tidying:线程池处于整理状态,此时没有正在执行的任务。

5.terminated :线程池处于终止状态。

线程池状态的变化过程

1.当线程池创建后处于running状态。

2.1 若此时调用了shutdown()方法,那么线程池将处于shutdown状态,不接受新的任务请求,但会继续执行队列中的任务,当队列中的任务为空且没有正在执行的任务时,线程池的状态为tidying。

2.2 若此时调用了shutdownnow()方法,那么线程池将处于stop状态,不接受新的任务请求并且不执行队列中的任务,此时线程池的状态为tidying。

3.当线程池的状态为tidying时,当terminated()方法处理完毕后,线程池的状态为trrminated。

任务的执行流程

1.当调用了execute()或者submit()方法向线程池提交一个任务后,首先判断当前线程池中的线程个数是否大于核心线程数。

2.如果当前线程池的线程个数小于核心线程数,则创建一个核心线程来处理任务。

3.如果当前线程池的线程个数大于核心线程数,则将任务放入到队列中,如果放入队列成功,那么该任务将等待被空闲的线程处理,如果放入队列失败(队满),则判断当前线程池中的线程个数是否达到所允许的最大值,若未达到则创建一个普通线程去处理任务,否则根据预定义的处理策略去进行处理。

详解Java中的线程池

5.executors工具类

java中提供了executors工具类,用于直接创建executor。

cachethreadpool

?
1
2
3
public static executorservice newcachedthreadpool() {
  return new threadpoolexecutor(0, integer.max_value,60l, timeunit.seconds,new synchronousqueue<runnable>());
}

cachethreadpool创建的都是普通线程(其核心线程数为0)、线程池的最大线程数为integer.max_value、线程的空闲时间为60秒,此方式适合大量耗时短的任务、不适合大量耗时长的任务。

*由于创建的都是普通线程,且空闲时间为60秒,则仍有可能会频繁的创建线程。

fixedthreadpool

?
1
2
3
public static executorservice newfixedthreadpool(int nthreads) {
  return new threadpoolexecutor(nthreads, nthreads,0l, timeunit.milliseconds,new linkedblockingqueue<runnable>());
}

fixedthreadpool创建的都是核心线程,其线程个数由入参决定,线程不会因为空闲时间而被销毁,适合预知任务数量的业务。

singlethreadexecutor

?
1
2
3
public static executorservice newsinglethreadexecutor() {
  return new finalizabledelegatedexecutorservice(new threadpoolexecutor(1, 1,new linkedblockingqueue<runnable>()));
}

singlethreadexecutor使用一个核心线程来处理任务。

scheduledthreadpool

?
1
2
3
public static scheduledexecutorservice newscheduledthreadpool(int corepoolsize) {
    return new scheduledthreadpoolexecutor(corepoolsize);
}

*scheduledthreadpool支持定时执行任务以及固定间隔执行任务。

singlethreadscheduledexecutor

?
1
2
3
public static scheduledexecutorservice newsinglethreadscheduledexecutor() {
    return new delegatedscheduledexecutorservice(new scheduledthreadpoolexecutor(1));
}

*singlethreadscheduledexecutor支持一个线程的定时执行任务以及固定间隔执行任务。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public interface scheduledexecutorservice extends executorservice {
 
  /**
   * 在指定的延迟时间到达后执行任务一次
   */
  public scheduledfuture<?> schedule(runnable command,long delay, timeunit unit);
 
  /**
   * 在指定的延迟时间到达后执行任务一次
   */
  public <v> scheduledfuture<v> schedule(callable<v> callable,long delay, timeunit unit);
 
  /**
   * 在指定的初始化延迟时间到达后执行任务一次,往后每隔period时间执行任务一次.
   */
  public scheduledfuture<?> scheduleatfixedrate(runnable command,long initialdelay,long period,timeunit unit);
 
  /**
   * 在指定的初始化延迟时间到达后执行任务一次,往后每次任务执行完毕后相隔delay时间执行任务一次.
   */
  public scheduledfuture<?> schedulewithfixeddelay(runnable command,long initialdelay,long delay,timeunit unit);
 
}

workstealingpool

?
1
2
3
public static executorservice newworkstealingpool(int parallelism) {
    return new forkjoinpool(parallelism,forkjoinpool.defaultforkjoinworkerthreadfactory,null, true);
}

workstealingpool创建一个并行级别的线程池,同一时刻最多只能有指定个数个线程正在执行任务,创建时直接指定同一时刻最多能允许的并行执行的线程个数即可,如果不传则使用cpu的核数。

newworkstealingpool方法内部返回一个forkjoinpool实例,forkjoinpool是java7新提供的线程池,同样继承abstactexecutorservice。

*作用类似于semaphore。

以上所述是小编给大家介绍的java中的线程池详解整合,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!

原文链接:https://www.cnblogs.com/funyoung/p/10530986.html