java中常见的四种线程池

版权声明：未经允许禁止转载 https://blog.csdn.net/weixin_38481963/article/details/86696528

1.CachedThreadPool （弹性缓存线程池）

    创建之初，线程池中没有一个线程，当通过execute()和submit()方法提交任务时，如果有空的线程，则用空的线程执行该任务，否则，创建新的线程来执行该任务。创建线程的最大值，取决于最大默认值。默认超过60s空闲，线程就会被回收。

示例如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//定义任务
class Task implements Runnable{
    public void run(){
        System.out.println("Task : " + Thread.currentThread().getName());
    }
}

public class MyThread {
    public static void main (String []args) {
        ExecutorService exe = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++)
        {
            exe.execute(new Task());   //提交任务到线程池，等待执行
            try{
                Thread.sleep(1000);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        exe.shutdown();
    }
}

2.FixedThreadPool（定长线程池）

    创建一个定长的线程池。每提交一个任务，则创建一个工作线程，达到最大线程数目后，进入排序队列。
    该线程池不会释放空闲线程，对资源有一定的占用和浪费。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Task implements Runnable{
    public void run(){
        System.out.println("Task : " + Thread.currentThread().getName());
    }
}

public class MyThread {

    public static void main (String []args) {
        ExecutorService exe = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++)
        {
            exe.execute(new Task());
        }
        exe.shutdown();
    }
}

结果：

Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-4
Task : pool-1-thread-5
Task : pool-1-thread-2
Task : pool-1-thread-3

可见一直在使用这5个线程执行任务。

3.SingleThreadExecutor（单线程池）

    顾名思义，只有一个线程的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Task implements Runnable{
    public void run(){
        System.out.println("Task : " + Thread.currentThread().getName());
    }
}
public class MyThread {
    public static void main (String []args) {
        ExecutorService exe = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++)
        {
            exe.execute(new Task());
        }
        exe.shutdown();
    }
}

结果：

Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1
Task : pool-1-thread-1

所有任务均由这一个线程执行。

4.ScheduledThreadPool（定时器线程池）

    创建定长的线程池，支持定时以及周期性的任务执行。

定时执行：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class Task implements Runnable{
    public void run(){
        System.out.println("Task : " + Thread.currentThread().getName());
    }
}

public class MyThread {

    public static void main (String []args) {
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
        ses.schedule(new Task(),3,TimeUnit.SECONDS);
    }
}

表示延迟3s执行。

周期性任务执行：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class Task implements Runnable{
    public void run(){
        System.out.println("Task : " + Thread.currentThread().getName());
    }
}

public class MyThread {

    public static void main (String []args) {
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
        ses.scheduleAtFixedRate(new Task(),1,3, TimeUnit.SECONDS);
    }
}

表示延迟1秒后每3秒执行一次