What are the four ways to create a thread pool in java

The four ways java creates a thread pool are: 1. newCachedThreadPool creates a cacheable thread pool; 2. newFixedThreadPool creates a fixed-length thread pool; 3. newScheduledThreadPool creates a fixed-length thread pool.

Java provides four thread pools through Executors, which are:
newCachedThreadPool creates a cacheable thread pool. If the thread pool length exceeds processing needs, it can Flexibly recycle idle threads. If there is no way to recycle idle threads, create new threads.

newFixedThreadPool creates a fixed-length thread pool that can control the maximum number of concurrent threads. Exceeding threads will wait in the queue.

newScheduledThreadPool creates a fixed-length thread pool that supports scheduled and periodic task execution.

newSingleThreadExecutor creates a single-threaded thread pool, which will only use a unique worker thread to execute tasks, ensuring that all tasks are executed in the specified order (FIFO, LIFO, priority).

For details, please refer to the blogger's blog Java Concurrent Programming: Use of Thread Pool

1.newCachedThreadPool The thread pool here is infinite. When a thread completes its task, this thread can Next complete the task that will be assigned instead of creating a new thread.

public static void main(String[] args) {  
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
        for (int i = 0; i < 10; i++) {  
            final int index = i;  
            try {  
                Thread.sleep(10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            cachedThreadPool.execute(new Runnable() {  
                public void run() {  
                    System.out.println(index);  
                }  
            });  
        }  
    }

2.newFixedThreadPool

public static void main(String[] args) {  
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
        for (int i = 0; i < 10; i++) {  
            final int index = i;  
            fixedThreadPool.execute(new Runnable() {  
                public void run() {  
                    try {  
                        System.out.println(index);  
                        Thread.sleep(10);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            });  
        }  
    }

3.newScheduledThreadPoo

public static void main(String[] args) {  
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
        for (int i = 0; i < 10; i++) {  
            scheduledThreadPool.schedule(new Runnable() {  
                public void run() {  
                    System.out.println("delay 3 seconds");  
                }  
            }, 3, TimeUnit.SECONDS);  
        }  
  
    }

4.newSingleThreadExecutor executes thread tasks in sequence But unlike a single thread, this thread pool can only exist in one Thread, after this thread dies, another thread will make up

public static void main(String[] args) {  
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
        for (int i = 0; i < 10; i++) {  
            final int index = i;  
            singleThreadExecutor.execute(new Runnable() {  
                public void run() {  
/*                  System.out.println(index);*/  
                    try {  
                        System.out.println(index);  
                        Thread.sleep(2000);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            });  
        }  
    }

Recommended tutorial: "java tutorial"

The above is the detailed content of What are the four ways to create a thread pool in java. For more information, please follow other related articles on the PHP Chinese website!