JavaWeb14-线程池

目录

 

1.传统线程的缺点

2.线程池的定义

3.线程池的优点

4.线程池的创建/使用(2类7种)

4.1.通过Executors(执行器)自动创建(6种)

①Executors.newFixedThreadPool:创建⼀个固定⼤⼩的线程池,可控制并发的线程数,超出的线程会在队列中等待。

--->PS:submit VS execute

--->PS:有返回值的线程池实现

--->PS:线程池中的线程工厂

②Executors.newCachedThreadPool:创建⼀个可缓存的线程池,若线程数超过处理所需,缓存⼀段时间后会回收,若线程数量不够,则新建线程,线程数随任务量而定(前提CPU性能好)。

③Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执⾏顺序。

--->PS:(常见面试题)newSingleThreadExecutor:创建单个线程数的线程池,那为何不直接使用线程?单线程线程池的意义?

④Executors.newScheduledThreadPool:创建⼀个可以执⾏延迟任务的线程池。

--->a.延迟执行一次

--->b.固定频率执行scheduleAtFixedRate

--->c.固定频率执行scheduleWithFixedDelay

 --->PS:scheduleAtFixedRate VS scheduleWithFixedDelay

⑤Executors.newSingleThreadScheduledExecutor:创建⼀个单线程的可以执行延迟任务的线程池。

⑥Executors.newWorkStealingPool:根据当前服务器的CPU创建⼀个抢占式执⾏的线程池(任务执⾏顺序不确定)【JDK 1.8 添加】。

4.2.通过ThreadPoolExecutor手动创建(1种)

⑦ThreadPoolExecutor:重点掌握,最原始方式,推荐使用。

--->Executors自动创建线程池返回的线程池对象的弊端如下:

--->a.ThreadPoolExecutor 参数说明(包含 7 个参数可供设置,最少需要设置5个参数)

--->b.线程池执行流程

--->c.线程池拒绝策略(4【JDK提供】+1【自定义】)

5.线程池状态(5种)

①RUNNING:

②SHUTDOWN:

③STOP:

④TIDYING:

⑤TERMINATED:

a.各个状态的转换过程

b.shutdown VS shutdownNow

6.究竟选用哪种线程池?


1.传统线程的缺点

  • 有任务时创建线程,没任务时结束线程:创建线程需要开辟本地线程栈、虚拟机栈、程序计数器等私有线程内存,消耗的时候也需要释放这些内存。频繁地创建和销毁需要⼀定的开销。

  • 线程没有任务队列的任务管理功能:当任务数远远⼤于线程可以承载的数量之后,不能友好地进⾏任务拒绝。

2.线程池的定义

线程池(ThreadPool)是⼀种基于池化思想管理和使⽤线程的机制。

它是将多个线程预先存储在⼀个“池⼦”内,当有任务出现时可以避免重新创建和销毁线程所带来性能开销,只需要从“池⼦”内取出相应的线程执⾏对应的任务即可。

池化思想在计算机的应⽤也⽐较⼴泛:

  • 内存池(Memory Pooling):预先申请内存,提升申请内存速度,减少内存碎⽚。

  • 连接池(Connection Pooling):预先申请数据库连接,提升申请连接的速度,降低系统的开销。

  • 实例池(Object Pooling):循环使⽤对象,减少资源在初始化和释放时的昂贵损耗。

3.线程池的优点

  1. 复用线程:避免线程重复创建和销毁的性能开销。
  2. 提⾼响应速度:任务到达时,⽆需等待线程创建即可⽴即执⾏。
  3. 控制线程数量:避免因线程创建过多而导致OOM(out of memory内存溢出)情况。
  4. 提供内存管理功能:可实现任务缓存和任务拒绝。
  5. 提供更多功能:比如定时任务,允许任务延期执⾏或定期执⾏。

同时阿⾥巴巴在其《Java开发⼿册》中也强制规定:线程资源必须通过线程池提供,不允许在应⽤中⾃⾏显式创建线程。

4.线程池的创建/使用(2类7种)

4.1.通过Executors(执行器)自动创建(6种)

Executors.newFixedThreadPool:创建⼀个固定⼤⼩的线程池,可控制并发的线程数,超出的线程会在队列中等待。

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

/**
 * 创建一个固定大小的线程池
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //1.创建了一个包含5个线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        //2.使用submit线程池执行任务一
        for (int i = 0; i < 5; i++) {
            //给线程池添加任务
            threadPool.submit(new Runnable() { //匿名内部类
                @Override
                public void run() {
                    System.out.println("线程名称:" + Thread.currentThread().getName());
                }
            });
        }

        //2.使用execute线程池执行任务二
        for (int i = 0; i < 10; i++) {
            //给线程池添加任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名称:" + Thread.currentThread().getName());
                }
            });
        }
    }
}

JavaWeb14-线程池_第1张图片

--->PS:submit VS execute

 

  • submit:既支持有返回值,也支持无返回值。(推荐使用)
  • execute:只支持无返回值。

--->PS:有返回值的线程池实现

import java.util.Random;
import java.util.concurrent.*;

/**
 * 有返回值的线程池
 */
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        Future result = threadPool.submit(new Callable() {
            @Override
            public Integer call() throws Exception{
                int num = new Random().nextInt(10);
                System.out.println("生成随机数:" + num);
                return num;
            }
        });

        System.out.println("得到线程池返回结果:" + result.get()); //会有阻塞,会等到拿到返回值之后再去执行后面的代码
    }
}

JavaWeb14-线程池_第2张图片

上面代码是使用默认的线程工厂。

--->PS:线程池中的线程工厂

作用:为线程池提供线程的创建。

提供的功能:

  1. 设置线程池中的线程的命名规则。
  2. 设置线程的优先级。
  3. 设置线程的分组。
  4. 设置线程的类型(用户线程、守护/后台线程)。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import static java.lang.Thread.MAX_PRIORITY;

/**
 *线程工厂示例演示
 */
public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        //创建线程工厂
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                //!!!一定要注意要把任务Runnable设置给新创建的线程
                Thread thread = new Thread(r);
                //设置线程的命名规则
                thread.setName("我的线程-" + r.hashCode());
                //设置线程的优先级
                thread.setPriority(MAX_PRIORITY);
                return thread;
            }
        };

        ExecutorService service = Executors.newFixedThreadPool(5,factory);
        for (int i = 0; i < 5; i++) {
            service.submit(() -> {
                //任务
                Thread thread = Thread.currentThread();
                System.out.println("线程池开始执行了:" + thread.getName() + ",线程优先级:" + thread.getPriority());
            });
        }
    }
}

JavaWeb14-线程池_第3张图片

线程池里的线程永远处于存活状态,不会自动停止,除非调用线程池终止执行方法。

JavaWeb14-线程池_第4张图片

Executors.newCachedThreadPool:创建⼀个可缓存的线程池,若线程数超过处理所需,缓存⼀段时间后会回收,若线程数量不够,则新建线程,线程数随任务量而定(前提CPU性能好)。

优点:更多任务数量产⽣相应的线程池。 当有突发的大量的任务时,建议使用此方式。

缺点:占⽤资源数量⽐较多。

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

/**
 * 带缓存的线程池
 */
public class ThreadPoolDemo4 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {//任务数量总共有1000个,最终执行结果 线程数量大概是300多个
            //i必须定义一个参数,才能去使用,必须是一个确定的参数
            int finalI = i;
            service.submit(() -> {
                System.out.println("i:" + finalI + "|线程名称" + Thread.currentThread().getName());
            });
        }
    }
}

JavaWeb14-线程池_第5张图片

若不关闭,会一直执行下去。

Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执⾏顺序。

--->PS:(常见面试题)newSingleThreadExecutor:创建单个线程数的线程池,那为何不直接使用线程?单线程线程池的意义?

  1. 复用线程。
  2. 单线程的线程池提供了任务队列和拒绝策略(当任务队列满了Integer.MAX_VALUE之后,新来的任务就会执行拒绝策略)。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo7 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("任务:" + finalI + "线程名:" + Thread.currentThread().getName());
                }
            });
        }
    }
}

JavaWeb14-线程池_第6张图片

Executors.newScheduledThreadPool:创建⼀个可以执⾏延迟任务的线程池。

--->a.延迟执行一次

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

/**
 * 创建执行定时任务的线程池
 */
public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间:" + LocalDateTime.now());
        //执行一次的定时任务
        scheduleTest(service);
    }
    
    /**
     * 执行一次的定时任务
     * @param service
     */
    private static void scheduleTest(ScheduledExecutorService service) {
        //执行定时任务(延迟3秒执行)。这个延迟任务只能执行一次,不能继续执行。
        //延迟执行一次定时任务
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行了任务:" + LocalDateTime.now());//参数1:执行的任务
            }
        },3, TimeUnit.SECONDS);//参数2:延迟多久进行执行; 参数3:是参数2的时间单位描述
    }
}

JavaWeb14-线程池_第7张图片

--->b.固定频率执行scheduleAtFixedRate

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

/**
 * 创建执行定时任务的线程池
 */
public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间:" + LocalDateTime.now());

        //2s之后开始执行定时任务,定时任务每隔4s执行一次
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:" + LocalDateTime.now());
            }
        },2,4, TimeUnit.SECONDS);
    }
}

JavaWeb14-线程池_第8张图片

--->c.固定频率执行scheduleWithFixedDelay

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

/**
 * 创建执行定时任务的线程池
 */
public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间:" + LocalDateTime.now());

        //2s之后开始执行定时任务,定时任务每隔4s执行一次
        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行时间:" + LocalDateTime.now());
            }
        },2,4,TimeUnit.SECONDS);
    }
}

JavaWeb14-线程池_第9张图片

 --->PS:scheduleAtFixedRate VS scheduleWithFixedDelay

①scheduleAtFixedRate 是以上⼀次任务的开始时间,作为下次定时任务的参考时间的(参考时间+延迟任务=任务执⾏)。

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

/**
 * 创建执行定时任务的线程池
 */
public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间:" + LocalDateTime.now());

        //2s之后开始执行定时任务,定时任务每隔4s执行一次
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:" + LocalDateTime.now());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },2,4, TimeUnit.SECONDS);
    }
}

JavaWeb14-线程池_第10张图片

注意:

如果任务执⾏时间⼤于延迟任务设定的间隔时间,则会以任务执行时间为定时任务间隔周期来执行,即哪个值大就用哪个值作为定时任务间隔周期。

public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间:" + LocalDateTime.now());

        //2s之后开始执行定时任务,定时任务每隔3s执行一次
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:" + LocalDateTime.now());
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },2,3, TimeUnit.SECONDS);
    }
}

JavaWeb14-线程池_第11张图片

②scheduleWithFixedDelay 是以上⼀次任务的结束时间,作为下次定时任务的参考时间的。

public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间:" + LocalDateTime.now());

        //2s之后开始执行定时任务,定时任务每隔4s执行一次
        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行时间:" + LocalDateTime.now());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },2,4,TimeUnit.SECONDS);
    }
}

JavaWeb14-线程池_第12张图片

Executors.newSingleThreadScheduledExecutor:创建⼀个单线程的可以执行延迟任务的线程池。

newSingleThreadScheduledExecutor是newScheduledThreadPool的单线程版本。

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

public class ThreadPoolDemo6 {
    public static void main(String[] args) {
        //创建执行定时任务的单线程线程池
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        System.out.println("添加任务的时间:" + LocalDateTime.now());
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:" + LocalDateTime.now());
            }
        },2, TimeUnit.SECONDS);
    }
}

JavaWeb14-线程池_第13张图片

Executors.newWorkStealingPool:根据当前服务器的CPU创建⼀个抢占式执⾏的线程池(任务执⾏顺序不确定)【JDK 1.8 添加】。

优点:智能、高效。

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

public class ThreadPoolDemo8 {
    public static void main(String[] args) {
        //根据当前设备的配置自动生成线程池
        ExecutorService service = Executors.newWorkStealingPool();

        for (int i = 0; i < 100; i++) {
            service.submit(() -> {
                System.out.println("线程名:" + Thread.currentThread().getName());
            });
        }

        while(!service.isTerminated()){
        }
    }
}

JavaWeb14-线程池_第14张图片

4.2.通过ThreadPoolExecutor手动创建(1种)

⑦ThreadPoolExecutor:重点掌握,最原始方式,推荐使用。

--->Executors自动创建线程池返回的线程池对象的弊端如下:

  1. FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
  2. CachedThreadPool:允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。

OOM代码演示:

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

/**
 * 演示OOM
 */
public class ThreadPoolDemo9 {
    static class OOMClass{
        //1M空间(M KB Byte)
        private byte[] bytes = new byte[1 * 1024 * 1024];
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        Object[] objects = new Object[15];

        for (int i = 0; i < 15; i++) {
            int finalI = i;
            service.execute(() -> {
                try {
                    Thread.sleep(finalI * 200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                OOMClass oomClass = new OOMClass();
                objects[finalI] = oomClass;
                System.out.println("执行第" + finalI + "次");
            });
        }
    }
}

JavaWeb14-线程池_第15张图片

JavaWeb14-线程池_第16张图片

JavaWeb14-线程池_第17张图片

JavaWeb14-线程池_第18张图片

JavaWeb14-线程池_第19张图片

关于参数设置

  • -XX:标准设置,所有 HotSpot 都⽀持的参数。
  • -X:⾮标准设置,特定的 HotSpot 才⽀持的参数。
  • -D:程序参数设置,-D参数=value,程序中使⽤:System.getProperty("获取")。
  • mx 是 memory max 的简称。

《阿里巴巴Java开发手册》中强制规定:线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样让程序员更加明确线程池的运行规则,规避资源耗尽的风险。

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 手动方式创建线程池
 */
public class ThreadPoolDemo10 {
    public static void main(String[] args) {
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
              Thread thread = new Thread(r);
              return thread;
            }
        };

        //手动方式创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>(100), factory, new ThreadPoolExecutor.DiscardPolicy());

        //设置任务
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("线程名称:" + Thread.currentThread().getName());
            });
        }

        //终止线程
        executor.shutdown();//当任务执行完直接就结束了
    }
}

JavaWeb14-线程池_第20张图片

--->a.ThreadPoolExecutor 参数说明(包含 7 个参数可供设置,最少需要设置5个参数)

JavaWeb14-线程池_第21张图片

  1. corePoolSize:核心线程数(正式员工的数量),可以⼤致理解为⻓期驻留的线程数⽬(除⾮设置了allowCoreThreadTimeOut)。对于不同的线程池,这个值可能会有很⼤区别,⽐如 newFixedThreadPool 会将其设置为 nThreads,⽽对于 newCachedThreadPool 则是为0

  2. maximumPoolSize:最大线程数(正式员工+临时员工的数量),就是线程不够时能够创建的最⼤线程数。同样进⾏对⽐,对于newFixedThreadPool,当然就是 nThreads,因为其要求是固定⼤⼩,⽽ newCachedThreadPool 则是 Integer.MAX_VALUE。

  3. keepAliveTime:空闲线程的保活时间(针对临时员工),如果线程的空闲时间超过这个值,那么将会被关闭。注意此值⽣效条件必须满⾜:空闲时间超过这个值,并且线程池中的线程数少于等于核⼼线程数 corePoolSize。当然核⼼线程默认是不会关闭的,除⾮设置了allowCoreThreadTimeOut(true)那么核⼼线程也可以被回收。

  4. TimeUnit:对参数3的时间单位描述

  5. BlockingQueue:任务/阻塞队列,⽤于存储线程池的待执⾏任务。必须要设置参数值;若不设置参数值,默认为Integer.MAX_VALUE,也会导致OOM问题。

  6. threadFactory:用于生成线程的线程工厂,可设置线程属性,⼀般我们可以⽤默认的就可以了。

  7. handler:拒绝策略管理器,处理极端问题。当线程池已经满了,但是又有新的任务提交的时候,该采取什么策略由这个来指定。有⼏种⽅式可供选择,像抛出异常、直接拒绝然后返回等,也可以⾃⼰实现相应的接⼝实现⾃⼰的逻辑。

--->b.线程池执行流程

JavaWeb14-线程池_第22张图片

--->c.线程池拒绝策略(4【JDK提供】+1【自定义】)

JDK提供的4种:

JavaWeb14-线程池_第23张图片

①AbortPolicy(默认的拒绝策略):提示异常,拒绝执行。

JavaWeb14-线程池_第24张图片

②DiscardPolicy:忽略最新的任务。

JavaWeb14-线程池_第25张图片

③DiscardOldestPolicy:忽略旧任务(任务队列中的第一个任务)。

JavaWeb14-线程池_第26张图片

④CallerRunsPolicy:使用调用线程池的线程来执行任务~叫救援。

JavaWeb14-线程池_第27张图片

自定义的1种:

JavaWeb14-线程池_第28张图片

5.线程池状态(5种)

JavaWeb14-线程池_第29张图片

RUNNING:

线程池创建之后的初始状态,这是最正常的状态:接受新的任务,处理等待队列中的任务。

②SHUTDOWN:

线程池不再接受新的任务提交,但是会继续处理等待队列中的任务,将其执行结束。

STOP:

线程池不接受新的任务提交,不再处理等待队列中的任务,中断正在执⾏任务的线程。

TIDYING:

该状态下所有的任务都销毁了,workCount 为 0。会执⾏钩⼦⽅法 terminated()。

TERMINATED:

terminated() ⽅法结束后,线程池的状态就会变成这个。

a.各个状态的转换过程

  • RUNNING -> SHUTDOWN:当调⽤了 shutdown() 后,会发⽣这个状态转换,这也是最重要的;
  • (RUNNING or SHUTDOWN) -> STOP:当调⽤ shutdownNow() 后,会发⽣这个状态转换;
  • SHUTDOWN -> TIDYING:当任务队列和线程池都清空后,会由 SHUTDOWN 转换为 TIDYING;  
  • STOP -> TIDYING:当任务队列清空后,发⽣这个转换;
  • TIDYING -> TERMINATED:当 terminated() ⽅法结束后。

b.shutdown VS shutdownNow

  • shutdown 执⾏时线程池终⽌接收新任务,并且会将任务队列中的任务处理完;
  • shutdownNow 执⾏时线程池终⽌接收新任务,并且会终⽌执⾏任务队列中的任务。

6.究竟选用哪种线程池?

阿⾥巴巴《Java开发⼿册》给的答案:推荐使⽤ThreadPoolExecutor 的⽅式进⾏线程池的创建,因为这种创建⽅式更可控,并且更加明确了线程池的运⾏规则,可以规避⼀些未知的⻛险。

你可能感兴趣的:(JavaWeb,java)