Java에서 ThreadPoolExecutor 스레드 풀 사용법 소개

이 기사는 Java에서 ThreadPoolExecutor 스레드 풀의 사용법을 소개합니다. 이는 특정 참조 가치가 있으므로 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

Executors

Executors는 다양한 유형의 스레드 풀을 생성하는 팩토리 메소드를 제공하는 Java의 도구 클래스입니다.

위 그림에서도 볼 수 있듯이 Executor의 스레드 풀을 생성하는 방법이 나와 있습니다. ExecutorService 인터페이스를 구현하는 모든 스레드 풀을 생성하는 것입니다. 일반적으로 사용되는 방법은 다음과 같습니다.

newFixedThreadPool(int Threads): 고정된 수의 스레드로 스레드 풀을 생성하고 초과 스레드는 대기열에서 대기합니다.

newCachedThreadPool(): 캐시 가능한 스레드 풀을 만듭니다. 스레드 풀의 길이가 처리 요구 사항을 초과하면 유휴 스레드를 유연하게 재활용할 수 있습니다(60초). 재활용할 방법이 없으면 새 스레드가 생성됩니다.

newSingleThreadExecutor(): 고유한 작업 스레드만 사용하여 작업을 실행하는 단일 스레드 풀을 생성하여 실행 중에 오류가 발생하는 경우 모든 작업이 지정된 순서(FIFO, LIFO, 우선 순위)로 실행되도록 합니다. 작업의 경우 다른 스레드가 계속 실행됩니다.

newScheduledThreadPool(int corePoolSize): 대부분의 경우 Timer 클래스를 대체하는 데 사용할 수 있는 예약 및 주기적인 작업 실행을 지원하는 스레드 풀을 만듭니다.

newCachedThreadPool

최대 스레드 수는 Integer.MAX_VALUE입니다. 스레드 풀에 n개의 작업을 추가하면 이 n개의 작업이 모두 함께 실행됩니다.

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        Thread.currentThread().sleep(1000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        Thread.currentThread().sleep(1000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

newFixedThreadPool

        ExecutorService cachedThreadPool = Executors.newFixedThreadPool(1);
        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        Thread.currentThread().sleep(1000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        Thread.currentThread().sleep(1000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

newScheduledThreadPool

은 3초마다 한 번씩 실행됩니다.

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        Thread.currentThread().sleep(2000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, 3, TimeUnit.SECONDS);

newSingleThreadExecutor

각 작업을 순서대로 실행하세요. 각 작업이 실행된 후 다음 작업이 실행됩니다.

        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        System.out.println(Thread.currentThread().getName());
                        Thread.currentThread().sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        System.out.println(Thread.currentThread().getName());
                        Thread.currentThread().sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

Executor의 문제점은 무엇인가요

It Alibaba Java Development Manual에는 Executor를 사용하여 스레드 풀을 생성하면 OOM(OutOfMemory, 메모리 오버플로)이 발생할 수 있다고 언급되어 있는데, 그 이유에 대해서는 설명하지 않았으니 왜 Executor를 사용하면 안 되는지 살펴보겠습니다.

Executor 사용으로 인해 OOM이 발생하는 상황을 시뮬레이션하는 간단한 예부터 시작하겠습니다.

/**
 * @author Hollis
 */
public class ExecutorsDemo {
    private static ExecutorService executor = Executors.newFixedThreadPool(15);
    public static void main(String[] args) {
        for (int i = 0; i JVM 매개변수를 지정하면: -Xmx8m -Xms8m 위 코드를 실행하면 OOM이 발생합니다.<p></p><pre class="brush:php;toolbar:false">Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
    at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
    at com.hollis.ExecutorsDemo.main(ExecutorsDemo.java:16)

위 코드는 다음을 가리킵니다. ExecutorsDemo.java 라인 16은 코드에서 executor.execute(new SubThread())입니다.

Java에는 BlockingQueue의 두 가지 주요 구현, 즉 ArrayBlockingQueue와 LinkedBlockingQueue가 있습니다.

ArrayBlockingQueue는 배열로 구현된 제한된 차단 큐입니다.

public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity LinkedBlockingQueue는 연결 목록으로 구현된 제한된 차단 대기열입니다. 용량을 선택적으로 설정할 수 있습니다. 설정하지 않으면 최대 길이가 Integer.MAX_VALUE.<p></p><pre class="brush:php;toolbar:false">public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

인 무제한 차단 대기열이 됩니다. 여기서 문제는 LinkedBlockingQueue의 용량을 설정하지 않으면 기본 용량은 Integer.MAX_VALUE가 된다는 것입니다.

newFixedThreadPool에서 LinkedBlockingQueue를 생성할 때 LinkedBlockingQueue는 무제한 큐입니다. , 무한한 대기열의 경우 작업이 계속해서 대기열에 추가될 수 있습니다. 이 경우 작업이 너무 많아 메모리 오버플로 문제가 발생할 수 있습니다.

newCachedThreadPool 및 newScheduledThreadPool 이 두 가지 방법으로 생성되는 최대 스레드 수는 정수일 수 있습니다. .MAX_VALUE, 너무 많은 스레드를 생성하면 필연적으로 OOM이 발생합니다.

ThreadPoolExecutor는 스레드 풀을 생성합니다.

기본 구현을 사용하지 않기 위해 Executor를 사용하여 스레드 풀을 생성하지 마십시오. 그런 다음 ThreadPoolExecutor의 생성자를 직접 호출할 수 있습니다. 함수를 생성할 때 BlockQueue의 용량을 지정하면 됩니다.

ExecutorService executor = new ThreadPoolExecutor(10, 10,
        60L, TimeUnit.SECONDS,
        new ArrayBlockingQueue(10));

이 경우 제출된 스레드 수가 현재 사용 가능한 스레드 수를 초과하면 java.util.concurrent가 발생합니다. 현재 스레드 풀에서 사용하는 큐는 제한된 큐이기 때문입니다. 큐가 가득 차면 계속해서 새로운 요청을 처리할 수 없습니다.

ThreadPoolExecutor를 직접 정의하는 것 외에도 apache 및 guava와 같은 다른 방법이 있습니다.

IV 생성자

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<runnable> workQueue)
             
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<runnable> workQueue,
                              ThreadFactory threadFactory)
             
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<runnable> workQueue,
                              RejectedExecutionHandler handler)
             
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)</runnable></runnable></runnable></runnable>

int corePoolSize =>; 스레드 풀의 최대 코어 스레드 수

스레드 풀이 새 스레드를 생성할 때 현재 총 스레드 수가 corePoolSize보다 작으면 새 스레드는 corePoolSize를 초과하면 새 스레드는 비코어 스레드가 됩니다.

코어 스레드는 이 코어 스레드가 아무 작업도 수행하지 않더라도(유휴 상태) 기본적으로 항상 스레드 풀에서 유지됩니다.

如果指定 ThreadPoolExecutor 的 allowCoreThreadTimeOut 这个属性为 true, 那么核心线程如果不干活(闲置状态)的话, 超过一定时间(时长下面参数决定), 就会被销毁掉

很好理解吧, 正常情况下你不干活我也养你, 因为我总有用到你的时候, 但有时候特殊情况(比如我自己都养不起了), 那你不干活我就要把你干掉了

int maximumPoolSize
该线程池中线程总数最大值

线程总数 = 核心线程数 + 非核心线程数.

long keepAliveTime
该线程池中非核心线程闲置超时时长

一个非核心线程, 如果不干活(闲置状态)的时长超过这个参数所设定的时长, 就会被销毁掉

如果设置 allowCoreThreadTimeOut = true, 则会作用于核心线程

TimeUnit unit

keepAliveTime的单位, TimeUnit是一个枚举类型, 其包括:

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

BlockingQueue workQueue

一个阻塞队列, 用来存储等待执行的任务. 也就是说现在有10个任务, 核心线程 有四个, 非核心线程有六个, 那么这六个线程会被添加到 workQueue 中, 等待执行.

这个参数的选择也很重要, 会对线程池的运行过程产生重大影响, 一般来说, 这里的阻塞队列有以下几种选择:

SynchronousQueue: 这个队列接收到任务的时候, 会直接提交给线程处理, 而不保留它, 如果所有线程都在工作怎么办？ 那就*新建一个线程来处理这个任务！所以为了保证不出现的错误, 使用这个类型队列的时候, maximumPoolSize 一般指定成 Integer.MAX_VALUE, 即无限大.

LinkedBlockingQueue: 这个队列接收到任务的时候, 如果当前线程数小于核心线程数, 则核心线程处理任务; 如果当前线程数等于核心线程数, 则进入队列等待. 由于这个队列最大值为 Integer.MAX_VALUE , 即所有超过核心线程数的任务都将被添加到队列中，这也就导致了 maximumPoolSize 的设定失效, 因为总线程数永远不会超过 corePoolSize.

ArrayBlockingQueue: 可以限定队列的长度, 接收到任务的时候, 如果没有达到 corePoolSize 的值, 则核心线程执行任务, 如果达到了, 则入队等候, 如果队列已满, 则新建线程(非核心线程)执行任务, 又如果总线程数到了maximumPoolSize, 并且队列也满了, 则发生错误.

DelayQueue: 队列内元素必须实现 Delayed 接口, 这就意味着你传进去的任务必须先实现Delayed接口. 这个队列接收到任务时, 首先先入队, 只有达到了指定的延时时间, 才会执行任务.

ThreadFactory threadFactory

它是ThreadFactory类型的变量, 用来创建新线程.

默认使用 Executors.defaultThreadFactory() 来创建线程. 使用默认的 ThreadFactory 来创建线程时, 会使新创建的线程具有相同的 NORM_PRIORITY 优先级并且是非守护线程, 同时也设置了线程的名称.

RejectedExecutionHandler handler

表示当拒绝处理任务时的策略, 有以下四种取值:

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常(默认).
ThreadPoolExecutor.DiscardPolicy：直接丢弃任务, 但是不抛出异常.
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务, 然后重新尝试执行任务(重复此过程)
ThreadPoolExecutor.CallerRunsPolicy：用调用者所在的线程来执行任务.

【相关推荐：Java视频教程】

위 내용은 Java에서 ThreadPoolExecutor 스레드 풀 사용법 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!