Quels sont les quatre pools de threads fournis avec Java ?

Quels sont les quatre pools de threads prédéfinis en Java ?

• newSingleThreadExexcutor : pool de threads avec un numéro de thread unique (nombre de threads principaux = nombre maximum de threads = 1)

• newFixedThreadPool : pool de threads avec un nombre fixe de threads (nombre de threads principaux = nombre maximum de threads = personnalisé )

• newCacheThreadPool : pool de threads pouvant être mis en cache (nombre de threads principaux = 0, nombre maximum de threads = Integer.MAX_VALUE)

• newScheduledThreadPool : pool de threads qui prend en charge les tâches planifiées ou périodiques (nombre de threads principaux = personnalisé, maximum nombre de threads = Integer .MAX_VALUE)

Quelles sont les différences entre les quatre pools de threads ?

Les quatre classes de pool de threads ci-dessus héritent toutes de ThreadPoolExecutor et renvoient directement le nouveau ThreadPoolExecutor (paramètres) une fois créées. La différence entre elles est que les paramètres du ThreadPoolExecutor (paramètres) défini sont différents et ThreadPoolExecutor hérite de la classe d'interface ExecutorService

• .

  newFixedThreadPool

Définition :
xecutorService executorService=Executors.newFixedThreadPool(2);

Inconvénients : La file d'attente de blocage de liste chaînée de LinkBlockQueue est utilisée lorsque la vitesse d'accumulation des tâches est supérieure à la vitesse de traitement, il est facile d'accumuler des tâches et d'échouer. Provoque un débordement de mémoire du MOO. (1), mais il y a La différence est qu'il y a un Layer FinalizingDelegatedExecutorService de plus, sa fonction :

• On peut voir que l'essence de fixExecutorService est ThreadPoolExecutor, donc fixExecutorService peut être forcé à ThreadPoolExecutor, mais singleExecutorService n'a rien à voir avec ThreadPoolExecutor , donc le transfert forcé échoue, donc newSingleThreadExecutor() Une fois créé, il ne peut pas modifier les paramètres de son pool de threads pour réellement obtenir un seul thread.

Inconvénients : la file d'attente de blocage de liste chaînée de LinkBlockQueue est utilisée lorsque la vitesse d'accumulation des tâches est supérieure à la vitesse de traitement, il est facile d'accumuler des tâches et de provoquer un débordement de mémoire du MOO

newCacheThreadPool

Définition : ExecutorService executorService=Executors.newCacheThreadPool. ();

Inconvénients : SynchronousQueue est une implémentation de BlockingQueue. C'est aussi une file d'attente, car le nombre maximum de threads est Integer.MAX_VALUE, donc lorsqu'il y a trop de threads, il est facile de déborder de mémoire MOO.

ScheduledThreadPool

Définition : ExecutorService executorService=Executors. newScheduledThreadPool(2);

源码：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        //ScheduledThreadPoolExecutor继承ThreadPoolExecutor
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    
public ScheduledThreadPoolExecutor(int corePoolSize) {
    //ScheduledThreadPoolExecutor继承ThreadPoolExecutor，故super()会调用ThreadPoolExecutor的构造函数初始化并返回一个ThreadPoolExecutor，而ThreadPoolExecutor使实现ExecutorService接口的
    //最终ScheduledThreadPoolExecutor也和上面几种线程池一样返回的是ExecutorService接口的实现类ThreadPoolExecutor
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

Quels sont les paramètres importants du pool de threads ?

La méthode de construction ThreadPoolExecutor est la suivante :

keepAliveTime fait référence à la durée pendant laquelle ces threads non principaux attendent un temps d'inactivité sans travail lorsque le nombre actuel de threads est compris entre [nombre de threads principaux, maximum nombre de threads], quittez simplement le pool de threads ;

La taille de la file d'attente n'a rien à voir avec le nombre maximum de threads Priorité de création de threads = threads principaux > file d'attente de blocage > threads étendus (lorsque le nombre actuel de threads est atteint). les threads principaux sont inférieurs au nombre maximum de threads. Pour développer les threads)

Si le nombre de threads principaux est de 5, la longueur de la file d'attente est de 3 et le nombre maximum de threads est de 10 : lorsque le nombre de threads continue de Augmentez, créez d'abord 5 threads principaux, puis jetez les threads dans Attendez que la file d'attente soit perdue, attendez que la file d'attente soit pleine (3 threads), à ce moment le nombre maximum de threads sera comparé (uniquement lorsque le maximum le nombre de threads à attendre pour que la file d'attente soit perdue peut apparaître), vous pouvez continuer à créer 2 threads (5+3+2), Si le nombre de threads dépasse le nombre maximum de threads, la politique de rejet sera exécutée

;

Si le nombre de threads principaux est de 5, la longueur de la file d'attente est de 3 et le nombre maximum de threads est de 7 : lorsque le nombre de threads continue d'augmenter, créez d'abord 5 threads principaux. pleine, les threads sont jetés dans la file d'attente. Lorsqu'il y a 2 threads dans la file d'attente, le nombre maximum de threads est atteint (5+2=7), mais la file d'attente n'est pas encore pleine, il n'est donc pas nécessaire de le faire. souciez-vous du nombre maximum de threads. Jusqu'à ce que la file d'attente soit pleine (3 threads bloqués), le nombre maximum de threads sera comparé (uniquement lorsque la file d'attente est pleine et que le nombre maximum de threads peut sortir), à ce moment-là, le noyau + file d'attente = 5+3=8>7= Le nombre maximum de threads, c'est-à-dire que le nombre maximum de threads a été atteint, alors la politique de rejet sera exécutée

• Si la file d'attente est définie sur LinkedBlockingQueue ; file d'attente illimitée, cette file d'attente est infinie et elle n'atteindra jamais la détermination maximale du thread. Comptez cette étape

如何自定义线程池

可以使用有界队列，自定义线程创建工厂ThreadFactory和拒绝策略handler来自定义线程池

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException, IOException {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        ThreadFactory threadFactory = new NameTreadFactory();
        RejectedExecutionHandler handler = new MyIgnorePolicy();
       ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, threadFactory, handler);
        executor.prestartAllCoreThreads(); // 预启动所有核心线程        
        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }
        System.in.read(); //阻塞主线程
    }
    static class NameTreadFactory implements ThreadFactory {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            doLog(r, e);
        }
        private void doLog(Runnable r, ThreadPoolExecutor e) {
            // 可做日志记录等
            System.err.println( r.toString() + " rejected");
//          System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
        }
    }

    static class MyTask implements Runnable {
        private String name;
        public MyTask(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                Thread.sleep(3000); //让任务执行慢点
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public String getName() {
            return name;
        }
        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

运行结果：

其中7-10号线程被拒绝策略拒绝了，1、2号线程执行完后，3、6号线程进入核心线程池执行，此时4、5号线程在任务队列等待执行，3、6线程执行完再通知4、5线程执行

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!