[JAVA]初识线程池及其基本应用

最新推荐文章于 2024-08-26 23:57:38 发布

破晓*

最新推荐文章于 2024-08-26 23:57:38 发布

阅读量513

点赞数 12

文章标签： java

本文链接：https://blog.csdn.net/2301_79757798/article/details/141425311

版权

并发是伴随着多核处理器的诞生而产生的，为了充分利用硬件资源，诞生了多线程技术。但是多线程又存在资源竞争的问题，引发了同步和互斥的问题，JDK1.5推出的java.util.concurrent(并发工具包来解决这些问题)

在Java并发包中一个最核心的组件是线程池，在了解线程池之前，我们需要知道Runnable接口的弊端。

在现实开发中，极少直接使用Runnable接口去创建线程了，因为它有两个重要的弊端：

1.Runnable新建线程，它的性能差，因为我们需要的时候去创建新线程，而创建线程本身的操作在Java中也需要消耗例如像CPU，内存这方面资源，如果频繁的新建线程，会对程序的整体执行产生负面影响

2.线程缺乏统一管理，可能无限制的新建线程，相互竞争，严重时会占用过多系统资源导致死机或内存溢出，原因是因为我们通过Runnable直接去新建线程的话，会导致线程无端的滥用，所以线程宝贵的资源在日常开发中受到管理和限制的，我们就要用到 线程池。

一，理解线程池中核心概念—线程复用

通过构建线程池，提前规划出多少线程，平时这些线程处于闲置状态，甚至长时间不用会被线程池回收，但是一旦有任务要运行的话。这些线程就会马上加载当前的任务。

利用线程池可以对线程进行有效的控制和管理。只有一定数量的任务能在不同的线程上同时运行，后面的任务则处于等待的状态，前面运行的程序执行完，这条线程被释放出来，后面的任务会被加载到这条线程上继续执行，这个理念就是线程复用，一个线程处理多个不同的任务，但总线程的数量是稳定的

基于这样的理念，在JUC里面提出了ThreadPool线程池的概念

重用存在的线程，减少线程对象创建，消亡的开销
线程总数可控，提高资源利用率
提供额外功能，定时执行，定期执行，监控等

在Java.util.concurrent中，提供了工具类Executors(调度器)对象来创建线程池，可创建的线程池有四种：

1.FixedThreadPool—定长线程池
CachedThreadPool—可缓存线程池
SingleThreadExecutor—单线程池
ScheduledThreadPool—调度线程池

二，线程池的四种类型

1.定长线程池

首先通过Executors.newFixedThreadPool(5)创建包含十个线程的定长线程池，然后for循环提交

100个任务，由于线程池只有十个，所以部分任务会等待线程空闲后执行，最后调用shutdown关闭线程池

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

public class ThreadPoolSample1 {
    public static void main(String[] args) {
        ExecutorService threadPool= Executors.newFixedThreadPool(10);//定长线程池-最大只允许有十个线程同时运行
        //定长线程池的特点是固定线程总数，空闲线程用于执行任务，如果线程都在使用，后续任务则处于等待状态
        for(int i=1;i<100;i++){
            final int index=i;  //i要调用，在实现类run中调用必须要使用final修饰
            threadPool.execute(new Runnable() {//用一个匿名类来实现接口，通过new对匿名类进行实例化
                @Override
                public void run() {     //用一个匿名类来实现这个接口，通过new对匿名类实例化，我们只需要在实现的run方法中书写自己线程要执行的代码
                    System.out.println(Thread.currentThread().getName()+":"+index);//打印当前线程的名字
                }
            });//execute方法用于执行指定的Runnable对象


        }
        //将当前线程池进行关闭
        threadPool.shutdown();
    }
}

运行结果：

它的有利之处：

1.可以有效控制线程的数量，避免过多线程竞争资源导致系统性能下降。

2.适应于需要限制并发度的场景，确保系统资源的合理利用

2.可缓存线程池


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

public class ThreadPoolSample2 {
    public static void main(String[] args){
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool= Executors.newCachedThreadPool();//创建一个可缓存线程池
    
        //提交任务给线程池运行
        for(int i=1;i<1000;i++){
            final int index=i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() +":"+index);
                }
            });
        }
        //关闭线程池
        threadPool.shutdown();
    }
}

通过Executors.newCachedThreadPool()创建了一个可缓存线程池，当有任务提交时，如果有空闲线程可用，就会重用该线程；如果没有空闲线程，将会创建一个新线程来执行任务

运行结果：

它的有利之处：

1.能够自动调整线程数量以适应任务负载的变化，具有较高的灵活性

2.当任务完成后，线程可以被回收并在需要的时候重新使用，减少了线程创建和销毁的开销

弊处：

1.由于线程数量没有限制，在高负载情况下可能会创建大量线程，导致系统资源耗尽

2.对于长时间运行的任务，可能会导致线程一直被占用，无法及时回收，影响其他任务的执行

3.单线程线程池

package com.project.pool;

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

public class ThreadPoolSample {
    public static void main(String[] args) {
        //调度器对象
        // ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单线程线程池
        for (int i = 1; i <= 1000; i++) {
            final int index = i;
            threadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
    }
}

单线程线程池只有一个工作线程来执行提交任务，通过Executors.newSingleThreadExecutor()创建了一个单线程线程池，所有提交的任务将按这个顺序在这个唯一的线程中执行

它的有利之处：

1.任务按提交顺序执行，保证了任务的顺序性，适用于需要严格顺序执行的场景

2.避免了多线程并发带来的线程安全问题和资源竞争问题

弊处：

1.由于只有一个线程在执行任务，所以执行任务的速度可能较慢，特别是当任务执行时间较长时

2.不能充分利用多核处理器的优势，在处理大量任务时可能效率不高

4.可调用线程池

package com.project.pool;

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

public class ThreadPoolSample4 {
    public static void main(String[] args) {   //可调度线程池
        //调度线程池
        //创建可调度线程池，包含5个线程
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟一秒执行，每三秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(new Date() + "延迟一秒执行，每三秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }

}

可调度线程池是Java中一种特殊的线程池，它主要用于执行定时任务或者周期性任务，允许你在指定的延迟后执行任务，或者以固定的频率重复执行任务。

它的有利之处：