Java中四种线程池

最新推荐文章于 2023-01-20 14:15:54 发布

原创最新推荐文章于 2023-01-20 14:15:54 发布 · 222 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

线程池通过减少频繁创建和销毁线程带来的资源消耗，提高响应速度及线程管理效率。Java中提供了四种类型的ExecutorService线程池：缓存线程池，适合执行大量短生命周期的任务；定长线程池，维护固定数量线程，适合执行定时及周期性任务；单线程线程池，确保所有任务都在同一线程中按顺序执行；以及周期性任务定长线程池，用于定期执行任务。

线程池Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

降低资源消耗。
提高响应速度。
提高线程的可管理性。

Java中的四种线程池 . ExecutorService

缓存线程池

package lesson4_5;

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

public class Demo15 {
    /**
     * 缓存线程池
     * （长度无限制）
     * 任务加入后的执行流程
     *      1.  判断线程池是否存在空闲线程
     *      2.  存在则使用
     *      3.  不存在，创建线程 并放入线程池，然后使用
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

运行结果：

pool-1-thread-1锄禾日当午
pool-1-thread-3锄禾日当午
pool-1-thread-2锄禾日当午
pool-1-thread-3锄禾日当午

定长线程池

package lesson4_5;

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

public class Demo16 {
    /**
     * 定长线程池
     * （长度时指定的数值）
     * 任务加入后的执行流程：
     *      1.  判断线程池是否存在空闲线程
     *      2.  存在则使用
     *      3、  不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用
     *      4.  不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {

                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

运行结果：

pool-1-thread-1锄禾日当午
pool-1-thread-2锄禾日当午
pool-1-thread-1锄禾日当午

单线程线程池

package lesson4_5;

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

public class Demo17 {
    /**
     * 单线程线程池
     * 执行流程：
     *      1.  判断线程池 的那个线程 是否空闲
     *      2.  空闲则使用
     *      3.  不空闲，则等待 池中的单个线程空闲后 使用
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

运行结果：

pool-1-thread-1锄禾日当午
pool-1-thread-1锄禾日当午
pool-1-thread-1锄禾日当午
pool-1-thread-1锄禾日当午

周期性任务定长线程池

package lesson4_5;

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

public class Demo18 {
    /**
     * 周期性任务定长线程池
     * 执行流程：
     *      1.  判断线程池是否存在空闲线程
     *      2.  存在则使用
     *      3、  不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用
     *      4.  不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
     * 周期性任务执行时：
     *      定时执行，当某个时机触发时自动执行某任务
     * @param args
     */
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1.   定时执行一次
         * 参数1. 定时执行的任务
         * 参数2. 时长数字
         * 参数3. 时长数字的时间单位，TimeUtil的常量指定
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("锄禾日当午");
            }
        },5, TimeUnit.SECONDS);
        /**
         * 周期性执行任务
         * 参数1. 任务
         * 参数2. 延迟时长数字（第一次执行在什么时间以后）
         * 参数3. 周期时长数字（每隔多久执行一次）
         * 参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("汗滴禾下土");
            }
        },5,1,TimeUnit.SECONDS);
    }
}