Java 线程池参数

最新推荐文章于 2024-05-21 10:23:42 发布

m0_74295055

最新推荐文章于 2024-05-21 10:23:42 发布

阅读量616

点赞数 15

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/m0_74295055/article/details/137499466

版权

1、为什么要使用线程池

线程池能有效管控线程，统一分配任务，优化资源使用。

2、线程池的参数

创建线程池，在构造一个新的线程池时，必须满足下面的条件：

corePoolSize（线程池基本大小）必须大于或等于0；
maximumPoolSize（线程池最大大小）必须大于或等于1；
maximumPoolSize必须大于或等于corePoolSize；
keepAliveTime（线程存活保持时间）必须大于或等于0；
workQueue（任务队列）不能为空；
threadFactory（线程工厂）不能为空，默认为DefaultThreadFactory类（可以通过线程工厂对不同线程池的线程名称进行设置，以区分产生bug的线程是哪个池的）
handler（线程饱和策略）不能为空，默认策略为ThreadPoolExecutor.AbortPolicy。

线程池参数围绕两个核心，线程和任务。

线程相关的参数：核心线程数，最大线程数，线程存活保持时间，线程饱和策略，线程工厂。

任务相关的参数：任务队列。

3、线程池执行过程

1、创建核心线程处理任务，失败则继续

2、将任务添加到任务队列

3、创建非核心线程处理任务

4、线程饱和策略

4、核心参数分析

4.1 任务队列

4.1.1 直接提交队列SynchronousQueue

设置为SynchronousQueue队列，SynchronousQueue是一个特殊的BlockingQueue，它没有容量，每执行一个插入操作就会阻塞。一般使用SynchronousQueue都会要求为无界(maximumPoolSize=Integer.MAX_VALUE)。

public class PoolTask implements Runnable{
    public int i;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
    }

    public PoolTask(int i) {
        this.i = i;
    }
}

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new SynchronousQueue<>());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();

    }

执行结果：

4.1.2 有界的任务队列ArrayBlockingQueue

一般使用ArrayBlockingQueue来实现。使用ArrayBlockingQueue有界任务队列，若有新的任务需要执行时，线程池会创建新的线程，直到创建的线程数量达到corePoolSize时，会将新的任务加入到等待队列中。这里等待队列的任务数量设置为2，若等待队列已满，即超过ArrayBlockingQueue初始化的容量，则继续创建线程，直到线程数量达到maximumPoolSize设置的最大线程数量，若大于maximumPoolSize，则执行拒绝策略。

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2));
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();
    }

执行结果：

4.1.3 无界的任务队列LinkedBlockingQueue

一般使用LinkedBlockingQueue来实现。使用无界的任务队列，线程池的任务队列可以无限制添加新任务，而线程池创建的最大线程数就是corePoolSize设置的数量，这种情况下maximumPoolSize设置的值是不会生效的，就算等待队列中有许多未执行的任务，线程池的数量达到了corePoolSize的值后也不会增加新的线程。

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();
    }

运行结果：

4.1.4 优先任务队列PriorityBlockingQueue

一般使用PriorityBlockingQueue来实现。任务需要实现comparable接口，根据任务的优先级执行任务。

public class PoolTask implements Runnable, Comparable<PoolTask>{
    public int i;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
    }

    public PoolTask(int i) {
        this.i = i;
    }

    @Override
    public int compareTo(PoolTask o) {
        //升序排序
        return o.getI() - this.getI();
    }
}

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<>());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();
    }

运行结果：

4.2 线程饱和策略

4.2.1 ThreadPoolExecutor.AbortPolicy

线程池默认的阻塞策略。不执行此任务，而且抛出一个运行时异常（未检查的异常RejectedExecutionException）。

切记：ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。

ThreadPoolExecutor.DiscardPolicy

不执行此任务，而且不抛异常。（是个空方法）

public class PoolTask implements Runnable, Comparable<PoolTask>{
    public int i;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public PoolTask(int i) {
        this.i = i;
    }

    @Override
    public int compareTo(PoolTask o) {
        //升序排序
        return o.getI() - this.getI();
    }
}

public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果：

4.2.2 ThreadPoolExecutor.DiscardOldestPolicy

从队列里删除最老的任务（头部的一个任务），并再次execute 此task。

public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果：

4.2.3 ThreadPoolExecutor.CallerRunsPolicy

让调用execute方法的线程执行此command，会阻塞入口。

这是个调节机制，既不抛弃任务也不抛出异常，而是将某些任务回退到调用者，让调用者所在的线程去执行。

public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果：

4.2.4 用户自定义拒绝策略（最常用）

实现RejectedExecutionHandler，并自己定义策略模式

package com.example.dyc.mythreadpool;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class MyThreadPolicy implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if (r instanceof PoolTask){
            PoolTask poolTask = (PoolTask) r;
            if (poolTask.getI() != 6){
                return;
            }
            System.out.println("获取到六号任务，试图放入队列");
            BlockingQueue<Runnable> queue = executor.getQueue();
            while (true) {
                if (queue.remainingCapacity() > 0) {
                    queue.add(poolTask);
                    System.out.println("放入队列成功");
                    break;
                } else {
                    try {
                        System.out.println("放入队列失败，继续试图放入");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }
}

public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new MyThreadPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果：

5 常用线程池类型

java通过Executors提供四种线程池，分别为：

5.1 newCachedThreadPool

newCachedThreadPool创建一个可缓存的无界线程池，如果线程池长度超过处理需要，可灵活回收空线程，若无可回收，则新建线程。当线程池中的线程空闲时间超过60s，则会自动回收该线程，当任务超过线程池的线程数则创建新的线程，线程池的大小上限为Integer.MAX_VALUE,可看作无限大。

5.2 newFixedThreadPool

newFixedThreadPool创建一个指定大小的线程池，可控制线程的最大并发数，超出的线程会在LinkedBlockingQueue阻塞队列中等待。

5.3 newScheduledThreadPool

newScheduledThreadPool线程池支持定时以及周期性执行任务，创建一个corePoolSize为传入参数，最大线程数为整形的最大数的线程池

5.4 newSingleThreadExecutor

newSingleThreadExecutor创建一个单线程化的线程池，它只有一个线程，用仅有的一个线程来执行任务，保证所有的任务按照指定顺序（FIFO，LIFO，优先级）执行，所有的任务都保存在队列LinkedBlockingQueue中，等待唯一的单线程来执行任务。

m0_74295055

关注

15
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java 线程池参数

实现RejectedExecutionHandler，并自己定义策略模式@Override= 6){return;System.out.println("获取到六号任务，试图放入队列");System.out.println("放入队列成功");break;} else {try {System.out.println("放入队列失败，继续试图放入");i < 10;
复制链接

扫一扫