JAVA线程池简单理解

最新推荐文章于 2021-01-10 16:26:04 发布

置顶今天又是快乐的一天

最新推荐文章于 2021-01-10 16:26:04 发布

阅读量207

点赞数 2

分类专栏：线程文章标签： java 内核

本文链接：https://blog.csdn.net/qq_42360973/article/details/109562801

版权

线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

什么是线程池

线程池的基本思想是一种对象池，在程序启动时候就开辟一块内存空间,里面存放众多的(未死亡)的线程。池中线程执行调度由线程池管理器来处理。当有线程任务是，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源

两种线程模型

a. 用户级线程（ULK）
由应用本身管理，不依赖操作系统核心，不需要用户态/核心态切换
那么什么是内核态，什么是用户态呢？只要想一想现实生活中，处于社会核心的人与处于社会边缘的人有什么区别就能明白处于核心的人拥有的资源多！因此，内核态就是拥有资源多的状态，或者说访问资源多的状态，我们也称之为特权态，速度块。相对来说，用户态就是非特权态，在此种状态下访问的资源将受到限制。
在这里插入图片描述

b. 内核级线程（KLT）在JVM用的99%线程属于KLT,CPU管理，依赖操作系统
在这里插入图片描述
两种权限，用户访问用户空间，内核空间只能内核访问，JVM虽然安装在用户空间，但可以调用系统开放的API，创建线程，映射到底层内核线程，所以JVM的线程要切换用户态于内核态，Java依赖于内核线程，为了避免资源过度消耗重要中线用户线程。

优势

线程池的使用：

单个任务处理的时间比较短
需要处理的任务数量很大
优势：
a. 重要线程，减少线程创建，消亡的开销，提高性能
b. 提高响应速度
c. 提高线程的可管理性
d. 运用线程池能有效的控制线程最大并发数，可以根据系统的承受能力，调整线程池的线程数目，也就能防止消耗过多的内存，减少宕机几率。
f. 对线程进行一些简单的管理，比如：延时执行，定时循环执行的策略等。

Executor框架是一种将线程的创建和执行分离的机制。它基于Executor和ExecutorService接口，及这两个接口的实现类ThreadPoolExecutor展开，Executor有一个内部线程池，并提供了将任务传递到池中线程以获得执行的方法，可传递的任务有如下两种：通过Runnable接口实现的任务和通过Callable接口实现的任务。在这两种情况下，只需要传递任务到执行器，执行器即可使用线程池中的线程或新创建的线程来执行任务。执行器也决定了任务执行时间。

Java提供了四种线程池的实现：

（1）newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

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

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
（2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

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

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

（3）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
             //延迟1秒后每3秒执行一次
           scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                          System.out.println("延迟1秒后每3秒执行一次");
            }

      }, 1, 3, TimeUnit.SECONDS);
    }

（4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    //结果依次输出，相当于顺序执行各个任务
                    System.out.println(Thread.currentThread().getName() + "  " + index);
                }
            });
        }
    }