线程池的原理和配置

最新推荐文章于 2024-07-05 14:48:07 发布

xiaobo5264063

最新推荐文章于 2024-07-05 14:48:07 发布

阅读量186

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/xiaobo5264063/article/details/90246132

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

线程池的作用

降低资源消耗。通过重复利用已创建的线程，降低线程创建和销毁造成的资源消耗
提交响应速度。当有任务时，不需要等到线程创建。
方便线程的管理。使用线程池可以进行统一分配、调优和监控。

线程池的使用场景

线程池是为突然大量爆发的线程设计的，使用线程池创建好的线程，减少了创建和销毁线程所需的时间，从而提高效率。
如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。

线程池的四种创建方式

newCachedThreadPool();
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池的创建方式1
 * Create by wangxb
 * 2019-05-15 22:23
 */
public class Test1 {
    public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i< 10 ; i++){
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"-----------"+temp);
                }
            });
        }

    }
}

newFixedThreadPool();
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池的创建方式2
 * Create by wangxb
 * 2019-05-15 22:28
 */
public class Test2 {
    public static void main(String[] args) {
        // 可固定长度的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i< 10 ; i++){
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"-----------"+temp);
                }
            });
        }
    }
}

newScheduledThreadPool();
创建一个定长线程池，支持定时及周期性任务执行

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 线程池的创建方式3
 * Create by wangxb
 * 2019-05-15 22:32
 */
public class Test3 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i< 20 ; i++){
            final int temp = i;
            scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"-----------"+temp);
                }
            },1, TimeUnit.SECONDS);
        }
    }
}

newSingleThreadExecutor();
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证任务按照指定顺序(FIFO, LIFO, 优先级)执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 创建线程池方式4
 * Create by wangxb
 * 2019-05-15 22:33
 */
public class Test4 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i< 10 ; i++){
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"-----------"+temp);
                }
            });
        }
    }
}

自定义线程池

通过ThreadPoolExecutor类的构造方法创建和并发队列
ThreadPoolExecutor构造方法参数

序号	名称	类型	含义
1	corePoolSize	int	核心线程池大小，最多能运行的线程数
2	maximumPoolSize	int	最大线程池大小，最多能创建的线程数
3	keepAliveTime	long	线程最大空闲时间
4	unit	TimeUnit	时间单位
5	workQueue	BlockingQueue<Runnable>	线程等待队列
6	threadFactory	ThreadFactory	线程创建工厂
7	handler	RejectedExecutionHandler	拒绝策略

/**
 * 自定义线程池
 * Create by wangxb
 * 2019-05-15 23:19
 */

class Thread01 implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread()+"---------------------------");
    }
}
public class Test {

    public static void main(String[] args) {
        // 通过ThreadPoolExecutor类的构造方法，创建线程池对象
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 0L, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(3));
        // 添加线程
        threadPoolExecutor.execute(new Thread01());
        threadPoolExecutor.execute(new Thread01());
        threadPoolExecutor.execute(new Thread01());
        threadPoolExecutor.execute(new Thread01());
        threadPoolExecutor.execute(new Thread01());
    }
}

线程池配置

主要判断你的业务场景，IO密集和CPU密集
阻塞：即请求、数据库操作、循环等属于IO密集
IO密集
意思是该任务需要大量的IO，即大量的阻塞。在单线程上运行IO密集型的任务会导致浪费大量的
最大线程数一般设置：cpu核数乘以2（线程的等待时间和cpu运行时间都是1秒的话）
如果你的线程等待时间很大则最大线程数的个数一般设置：（线程等待时间与线程CPU时间之比 + 1）* CPU数目
CPU密集
意思是该任务需要大量的逻辑运算，相对少的IO操作，而没有阻塞，CPU一直全速运行。
最大线程数和核心线程数一般设置：cpu核数
线程等待时间所占比例越高，需要越多线程。
默认
如果不确定你的业务是io还是cpu，一般可以使用默认配置: 核心线程=cpu核数最大线程=cpu核数*2
后期根据业务和使用情况进行优化

使用Callable创建可返回结果的线程池

Thread和Runnable缺点是在线程结束无法获取返回结果，只能通过共享变量等其他方式实现
使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务，产生结果，而Future用来获得结果

使用Callable例子

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Callable创建可返回结果的线程池
 * Create by wangxb
 * 2019-05-16 21:00
 */
public class Test {
    public static void main(String[] args) throws Exception {
        System.out.println("主线程开始-------------------"+Thread.currentThread().getName());
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> result = executorService.submit(new Thread01());  // 等待结果会阻赛，可以放在子线程
        System.out.println("返回的结果是："+result.get());
        System.out.println("主线程结束-------------------");
    }
}

class Thread01 implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "------------");
        return "admin";
    }
}