Method: newCachedThreadPool creates a cacheable thread pool, newFixedThreadPool creates a fixed-length thread pool, newScheduledThreadPool creates a fixed-length thread pool, and newSingleThreadExecutor creates a single-threaded thread pool.

Four ways to create a thread pool

Java provides four threads through Executors Pools, respectively:

1. Use newCachedThreadPool

newCachedThreadPool to create a cacheable thread pool. If the length of the thread pool exceeds processing needs, idle threads can be flexibly recycled. If there is no recycling, create a new thread.

The characteristics of this type of thread pool are:

• There is almost no limit on the number of worker threads created (in fact, there is a limit, the number is Interger. MAX_VALUE), so you can Flexibly add threads to the thread pool.

• If no task is submitted to the thread pool for a long time, that is, if the worker thread is idle for the specified time (default is 1 minute), the worker thread will automatically terminate. After termination, if you submit a new task, the thread pool will recreate a worker thread.

• When using CachedThreadPool, you must pay attention to controlling the number of tasks. Otherwise, due to a large number of threads running at the same time, the system may be paralyzed.

The sample code is as follows:

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

2. Use newFixedThreadPool

to create a thread pool with a specified number of worker threads. Whenever a task is submitted, a worker thread is created. If the number of worker threads reaches the initial maximum number of the thread pool, the submitted task is stored in the pool queue.

FixedThreadPool is a typical and excellent thread pool. It has the advantages of a thread pool improving program efficiency and saving overhead when creating threads. However, when the thread pool is idle, that is, when there are no runnable tasks in the thread pool, it will not release the worker threads and will also occupy certain system resources.

The sample code is as follows:

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

Because the thread pool size is 3, each task sleeps for 2 seconds after outputting the index, so 3 numbers are printed every two seconds.

The size of the fixed-length thread pool is best set according to system resources such as Runtime.getRuntime().availableProcessors().

3. Use newSingleThreadExecutor

to create a single-threaded Executor, that is, only create a unique worker thread to perform tasks. It will only use the only worker thread. To execute tasks, ensure that all tasks are executed in the specified order (FIFO, LIFO, priority). If this thread ends abnormally, another one will replace it to ensure sequential execution. The biggest feature of a single worker thread is that it can ensure that tasks are executed sequentially, and no multiple threads are active at any given time.

The sample code is as follows:

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 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() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

4. Use newScheduledThreadPool

to create a fixed-length thread pool and support scheduled and periodic tasks. Execution, supporting scheduled and periodic task execution.

Delay execution for 3 seconds. The sample code for delayed execution is as follows:

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

means it will be executed every 3 seconds after a delay of 1 second. The sample code for regular execution is as follows:

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

More For programming-related knowledge, please visit: programming learning website! !

The above is the detailed content of What are the four methods of thread pool creation?. For more information, please follow other related articles on the PHP Chinese website!