Java常用线程池原理及使用方法解析

时间:2022-06-25 21:42:43

一、简介

什么是线程池

池的概念大家也许都有所听闻,池就是相当于一个容器,里面有许许多多的东西你可以即拿即用。java中有线程池、连接池等等。线程池就是在系统启动或者实例化池时创建一些空闲的线程,等待工作调度,执行完任务后,线程并不会立即被销毁,而是重新处于空闲状态,等待下一次调度。

线程池的工作机制?

在线程池的编程模式中,任务提交并不是直接提交给线程,而是提交给池。线程池在拿到任务之后,就会寻找有没有空闲的线程,有则分配给空闲线程执行,暂时没有则会进入等待队列,继续等待空闲线程。如果超出最大接受的工作数量,则会触发线程池的拒绝策略。

为什么使用线程池?

线程的创建与销毁需要消耗大量资源,重复的创建与销毁明显不必要。而且池的好处就是响应快,需要的时候自取,就不会存在等待创建的时间。线程池可以很好地管理系统内部的线程,如数量以及调度。

二、常用线程池介绍

Java类ExecutorService是线程池的父接口,并非顶层接口。以下四种常用线程池的类型都可以是ExecutorService。

单一线程池 Executors.newSingleThreadExecutor()
内部只有唯一一个线程进行工作调度,可以保证任务的执行顺序(FIFO,LIFO)

?
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
package com.test;
 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class PoolTest {
    public static void main(String[] args) {
        // 创建单一线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        List<String> list = new ArrayList<String>();
        list.add("first");
        list.add("second");
        list.add("third");
        list.forEach(o -> {
            // 遍历集合提交任务
            singleThreadExecutor.execute(new Runnable() {
 
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " : " + o);
                    try {
                        // 间隔1s
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        });
    }
}

执行结果:

pool-1-thread-1 : first

pool-1-thread-1 : second

pool-1-thread-1 : third

可缓存线程池 Executors.newCachedThreadPool()

如果线程池中有可使用的线程,则使用,如果没有,则在池中新建一个线程,可缓存线程池中线程数量最大为Integer.MAX_VALUE。通常用它来运行一些执行时间短,且经常用到的任务。

?
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
package com.test;
 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class PoolTest {
    public static void main(String[] args) {
        // 创建可缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        List<String> list = new ArrayList<String>();
        list.add("first");
        list.add("second");
        list.add("third");
        list.forEach(o -> {
 
            try {
                // 间隔3s
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            // 遍历集合提交任务
            cachedThreadPool.execute(new Runnable() {
 
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " : " + o);
                    try {
                        // 间隔1s
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        });
    }
}

执行结果:

pool-1-thread-1 : first

pool-1-thread-1 : second

pool-1-thread-1 : third

因为间隔时间长,下一个任务运行时,上一个任务已经完成,所以线程可以继续复用,如果间隔时间调短,那么部分线程将会使用新线程来运行。

把每个任务等待时间从3s调低至1s:

执行结果:

pool-1-thread-1 : first

pool-1-thread-2 : second

pool-1-thread-1 : third

定长线程池 Executors.newFixedThreadPool(int nThreads)
创建一个固定线程数量的线程池,参数手动传入

?
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
package com.test;
 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class PoolTest {
    public static void main(String[] args) {
        // 创建可缓存线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        List<String> list = new ArrayList<String>();
        list.add("first");
        list.add("second");
        list.add("third");
        list.add("fourth");
        list.forEach(o -> {
 
            try {
                // 间隔1s
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            // 遍历集合提交任务
            fixedThreadPool.execute(new Runnable() {
 
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " : " + o);
                    try {
                        // 间隔1s
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        });
    }
}

执行结果:

pool-1-thread-1 : first

pool-1-thread-2 : second

pool-1-thread-3 : third

pool-1-thread-1 : fourth

定时线程池 Executors.newScheduledThreadPool(int corePoolSize)
创建一个定长线程池,支持定时及周期性任务执行

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.test;
 
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class PoolTest {
    public static void main(String[] args) {
        // 创建定长线程池、支持定时、延迟、周期性执行任务
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " : 1秒后每隔3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }
}

执行结果:

pool-1-thread-1 : 1秒后每隔3秒执行一次

pool-1-thread-1 : 1秒后每隔3秒执行一次

pool-1-thread-2 : 1秒后每隔3秒执行一次

pool-1-thread-2 : 1秒后每隔3秒执行一次

pool-1-thread-2 : 1秒后每隔3秒执行一次

pool-1-thread-2 : 1秒后每隔3秒执行一次

pool-1-thread-2 : 1秒后每隔3秒执行一次

三、自定义线程池

常用构造函数:

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

参数说明:

1、corePoolSize 核心线程数大小,当线程数<corePoolSize ,会创建线程执行runnable

2、maximumPoolSize 最大线程数, 当线程数 >= corePoolSize的时候,会把runnable放入workQueue中

3、keepAliveTime 保持存活时间,当线程数大于corePoolSize的空闲线程能保持的最大时间。

4、unit 时间单位

5、workQueue 保存任务的阻塞队列

6、threadFactory 创建线程的工厂

7、handler 拒绝策略

任务执行顺序:

1、当线程数小于corePoolSize时,创建线程执行任务。

2、当线程数大于等于corePoolSize并且workQueue没有满时,放入workQueue中

3、线程数大于等于corePoolSize并且当workQueue满时,新任务新建线程运行,线程总数要小于maximumPoolSize

4、当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。

ThreadPoolExecutor默认有四个拒绝策略:

1、new ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException

2、new ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行

3、new ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务

4、new ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务

缓冲队列BlockingQueue:

BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列,允许两个线程同时向队列一个存储,一个取出操作。在保证并发安全的同时,提高了队列的存取效率。

常用的几种BlockingQueue:

  • ArrayBlockingQueue(int i):规定大小的BlockingQueue,其构造必须指定大小。其所含的对象是FIFO顺序排序的。
  • LinkedBlockingQueue()或者(int i):大小不固定的BlockingQueue,若其构造时指定大小,生成的BlockingQueue有大小限制,不指定大小,其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。
  • PriorityBlockingQueue()或者(int i):类似于LinkedBlockingQueue,但是其所含对象的排序不是FIFO,而是依据对象的自然顺序或者构造函数的Comparator决定。
  • SynchronizedQueue():特殊的BlockingQueue,对其的操作必须是放和取交替完成。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.test;
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
public class PoolTest {
    public static void main(String[] args) {
        // 工作队列
        LinkedBlockingDeque<Runnable> workQueue = new LinkedBlockingDeque<Runnable>();
        // 拒绝策略
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 10, 20, TimeUnit.MILLISECONDS, workQueue, handler);
        threadPoolExecutor.execute(new Runnable() {
 
            @Override
            public void run() {
                System.out.println("自定义线程池");
            }
        });
    }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

原文链接:https://www.cnblogs.com/yl-space/p/13353003.html