Hogyan működik a maximumPoolSize of ThreadPoolExecutor?

A ThreadPoolExecutorban a maximumPoolSize jön képbe, amikor a corePoolSize no nem elegendő a feladatok végrehajtásához, és ha az összes nemet lefoglalják a feladatok, akkor csak egy újabb lépcső jön létre a feladat végrehajtásához. Ez a nem maxPoolSize-ig nőhet.

Szerkesztés félreértette a maxPoolsize fogalmát. Kérjük, tekintse meg az alábbi linket.

http://www.bigsoft.co.uk/blog/index.php/2009/11/27/rules-of-a-threadpoolexecutor-pool-size

A ThreadPoolExecutor:

Ha a corePoolSize-nél több, de a maximumPoolSize-nél kevesebb szál fut, akkor csak akkor jön létre új szál, ha a várólista megtelt.

A sor soha nem töltődik be, mivel kapacitása 1000. Ha a kapacitást 1-ra módosítja, látni fogja, hogy a Threads létrejön.

A Executors osztály egy SynchronousQueue a newCachedThreadPool metódusaihoz, így szeretné fontolóra venni a használatát is.

Ha azt szeretné, hogy a ThreadPool új további szálat hozzon létre (a készlet méretének bővítéséhez a maximumPoolSize paraméter szerint), hajtsa végre ezt az egyszerű példát:

public class Main {

    public static void main(String[] args) throws InterruptedException {

        ThreadPoolExecutor tpe = new ThreadPoolExecutor(
                1, 2, 500, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(1));
        System.out.println("init pool size= " + tpe.getPoolSize() + ", queue size=" + tpe.getQueue().size());

        tpe.execute(new Task("1st", 10000));
        Thread.sleep(1000);
        print(tpe, "1st");

        tpe.execute(new Task("2nd", 0));
        Thread.sleep(1000);
        print(tpe, "2nd");

        tpe.execute(new Task("3d", 2000));
        Thread.sleep(1000);
        print(tpe, "3d");

        while (tpe.getPoolSize()>1) {           
            Thread.sleep(100);
        }
        System.out.println("pool size= " + tpe.getPoolSize() + ", queue size=" + tpe.getQueue().size());
        tpe.shutdown();
    }

    private static void print(ThreadPoolExecutor tpe, String name) {
        System.out.println("After " + name + " execute -  pool size= " + tpe.getPoolSize() + ", queue=" + tpe.getQueue());
    }

    private static class Task implements Runnable {

        private final String name;
        private final long time;

        Task(String name, long time) {
            this.name = name;
            this.time = time;
        }

        @Override
        public void run() {
            System.out.println("Run " + Thread.currentThread().getName() + "-" + name);
            try {
                Thread.sleep(time);
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Finish " + Thread.currentThread().getName() + "-" + name);
        }

        @Override
        public String toString() {
            return name;
        }

    }
}

Megkapja a kimenetet, amely bemutatja a maximumPoolSize és a keepAliveTime hatását:

init pool size= 0, queue size=0
Run pool-1-thread-1-1st
After 1st execute -  pool size= 1, queue=[]
After 2nd execute -  pool size= 1, queue=[2nd]
Run pool-1-thread-2-3d
After 3d execute -  pool size= 2, queue=[2nd]
Finish pool-1-thread-2-3d
Run pool-1-thread-2-2nd
Finish pool-1-thread-2-2nd
pool size= 1, queue size=0
Finish pool-1-thread-1-1st