Java线程的创建方式以及线程池的使用

Java线程的创建方式以及线程池的使用

一、线程的创建方式一

/**
  * 1.继承thread类,重写run方法
*/
@Test
void test1(){
    new threadDemo().start();
}

class threadDemo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

二、线程的创建方式二

/**
  * 2.实现runnable接口,重写run方法
*/
@Test
void test2(){
    new Thread(new runnableDemo()).start();
}

class runnableDemo implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

三、线程的创建方式三

/**
  * 3.实现Callable接口,重写call方法
*/
@Test
void test3(){
    FutureTask<Integer> futureTask = new FutureTask<>(new callAbleDemo());
    new Thread(futureTask, "threadName").start();

    Integer result = null;
    try {
        // 获取子线程执行的结果,此时主线程会被阻塞,会等到计算结果完成后,容易程序阻塞
        // 可以通过使用CompletableFuture,解决FutureTask的缺陷问题
        result = futureTask.get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

    System.out.println(result);  // 输出result为45
}


class callAbleDemo implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        return sum;
    }
}

由于futureTask.get()时会阻塞主线程,我们可以指定超时时间,表示在规定时间内仍未完成则直接抛异常,改造后的代码如下:

/**
  * 3.实现Callable接口,重写call方法
*/
@Test
void test3(){
    FutureTask<Integer> futureTask = new FutureTask<>(new callAbleDemo());
    new Thread(futureTask, "threadName").start();

    Integer result = null;
    try {
        // 获取子线程执行的结果,此时主线程会被阻塞,会等到计算结果完成后,容易程序阻塞
        // 可以通过使用CompletableFuture,解决FutureTask的缺陷问题
        // result = futureTask.get();
        result = futureTask.get(3, TimeUnit.SECONDS); // 指定超时时间,如果未执行完直接抛异常
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (TimeoutException e) {
        e.printStackTrace();
    }

    System.out.println(result);
}

class callAbleDemo implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        try {
            TimeUnit.SECONDS.sleep(5); // 沉睡5s,模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return sum;
    }
}

Java线程的创建方式以及线程池的使用_第1张图片

同时我们也可以使用FutureTaskisDone方法,这个方法的作用是不断地轮询判断是否操作已经完成,但是这容易耗费cpu资源,改造后的代码如下:

/**
  * 3.实现Callable接口,重写call方法
*/
@Test
void test3() throws ExecutionException, InterruptedException {
    FutureTask<Integer> futureTask = new FutureTask<>(new callAbleDemo());
    new Thread(futureTask, "threadName").start();

    Integer result = null;

    // isDone轮询,是否已经计算完成,容易耗费cpu资源
    while (true){
        if (futureTask.isDone()){
            // 可以通过使用CompletableFuture,解决FutureTask的缺陷问题
            result = futureTask.get();
            break;
        }else {
            System.out.println("还没完成呢");
        }
    }
    System.out.println(result);
}

class callAbleDemo implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        try {
            TimeUnit.SECONDS.sleep(1); // 沉睡1s,模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return sum;
    }
}

Java线程的创建方式以及线程池的使用_第2张图片

我们可以通过使用CompletableFuture,解决FutureTask的缺陷问题,FutureTask类图关系如下:

Java线程的创建方式以及线程池的使用_第3张图片

CompletableFuture

哔哩哔哩链接:https://www.bilibili.com/video/BV1ar4y1x727?p=22&vd_source=7c5f1f4c039688f19024d50ef51aaed1

从java8开始引入CompletableFuture,是Future的功能增强版,减少阻塞和轮询,可以传入回调对象,当异步任务完成或者发生异常时,自动调用回调对象的回调方法。

public static void main(String[] args) throws ExecutionException, InterruptedException {

    CompletableFuture.supplyAsync(() -> {
        System.out.println(Thread.currentThread().getName() + "----come in");
        int result = ThreadLocalRandom.current().nextInt(10);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----1秒钟后出结果:" + result);
        return result;
    }).whenComplete((v, e) -> {
        if (e == null) {
            System.out.println("-----计算完成,更新系统UpdateValue:" + v);
        }
    }).exceptionally(e -> {
        e.printStackTrace();
        System.out.println("异常情况:" + e.getCause() + "\t" + e.getMessage());
        return null;
    });

    System.out.println(Thread.currentThread().getName() + "线程先去忙其它任务");

    //主线程不要立刻结束,否则CompletableFuture默认使用的线程池会立刻关闭:暂停3秒钟线程
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Java线程的创建方式以及线程池的使用_第4张图片

不使用CompletableFuture默认使用的线程池:

public static void main(String[] args) throws ExecutionException, InterruptedException
{
    ExecutorService threadPool = Executors.newFixedThreadPool(3);

    try
    {
        CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "----come in");
            int result = ThreadLocalRandom.current().nextInt(10);
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("-----1秒钟后出结果:" + result);
            if(result > 2)
            {
                int i=10/0;
            }
            return result;
        },threadPool).whenComplete((v,e) -> {
            if (e == null) {
                System.out.println("-----计算完成,更新系统UpdateValue:"+v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println("异常情况:"+e.getCause()+"\t"+e.getMessage());
            return null;
        });

        System.out.println(Thread.currentThread().getName()+"线程先去忙其它任务");
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        threadPool.shutdown();
    }
    // 主线程不要立刻结束,否则CompletableFuture默认使用的线程池会立刻关闭:暂停3秒钟线程
    // try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
}

Java线程的创建方式以及线程池的使用_第5张图片

案例:电商比价需求

package com.bilibili.juc.cf;

import lombok.*;
import lombok.experimental.Accessors;

import java.awt.print.Book;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 *
 * 案例说明:电商比价需求,模拟如下情况:
 *
 * 1需求:
 *  1.1 同一款产品,同时搜索出同款产品在各大电商平台的售价;
 *  1.2 同一款产品,同时搜索出本产品在同一个电商平台下,各个入驻卖家售价是多少
 *
 * 2输出:出来结果希望是同款产品的在不同地方的价格清单列表,返回一个List
 * 《mysql》 in jd price is 88.05
 * 《mysql》 in dangdang price is 86.11
 * 《mysql》 in taobao price is 90.43
 *
 * 3 技术要求
 *   3.1 函数式编程
 *   3.2 链式编程
 *   3.3 Stream流式计算
 */
public class CompletableFutureMallDemo
{
    static List<NetMall> list = Arrays.asList(
            new NetMall("jd"),
            new NetMall("dangdang"),
            new NetMall("taobao"),
            new NetMall("pdd"),
            new NetMall("tmall")
    );

    /**
     * step by step 一家家搜查
     * List ----->map------> List
     * @param list
     * @param productName
     * @return
     */
    public static List<String> getPrice(List<NetMall> list,String productName)
    {
        // 格式:《mysql》 in taobao price is 90.43
        return list
                .stream()
                .map(netMall ->
                        String.format(productName + " in %s price is %.2f",
                                netMall.getNetMallName(),
                                netMall.calcPrice(productName)))
                .collect(Collectors.toList());
    }

    /**
     * List ----->List>------> List
     * @param list
     * @param productName
     * @return
     */
    public static List<String> getPriceByCompletableFuture(List<NetMall> list,String productName)
    {
        return list.stream().map(netMall ->
                CompletableFuture.supplyAsync(() -> String.format(productName + " in %s price is %.2f",
                netMall.getNetMallName(),
                netMall.calcPrice(productName))))
                .collect(Collectors.toList())
                .stream()
                .map(s -> s.join())
                .collect(Collectors.toList());
    }


    public static void main(String[] args)
    {
        long startTime = System.currentTimeMillis();
        List<String> list1 = getPrice(list, "mysql");
        for (String element : list1) {
            System.out.println(element);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒");

        System.out.println("--------------------");

        long startTime2 = System.currentTimeMillis();
        List<String> list2 = getPriceByCompletableFuture(list, "mysql");
        for (String element : list2) {
            System.out.println(element);
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime2 - startTime2) +" 毫秒");
    }
}

class NetMall
{
    @Getter
    private String netMallName;

    public NetMall(String netMallName)
    {
        this.netMallName = netMallName;
    }

    // 查询价格
    public double calcPrice(String productName)
    {
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        // ThreadLocalRandom.current().nextDouble():0-1之间的随机小数
        // "my".charAt(0)为m,这里与 + 连接,可以连接成一个数字,此处模拟一本书的价格
        return ThreadLocalRandom.current().nextDouble() * 2 + productName.charAt(0);
    }
}

Java线程的创建方式以及线程池的使用_第6张图片

CompletableFuture常用方法

1.获取计算结果和触发计算

join和get方法

都可以获取结果,但是jion在编译期间不会去检查是否有异常

Java线程的创建方式以及线程池的使用_第7张图片

Java线程的创建方式以及线程池的使用_第8张图片

get、join、getNow、complete演示:

public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
    group1();
}

/**
     * 获得结果和触发计算
     * @throws InterruptedException
     * @throws ExecutionException
     */
private static void group1() throws InterruptedException, ExecutionException, TimeoutException {
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "abc";
    });

    // System.out.println(completableFuture.get()); // 获取结果
    // System.out.println(completableFuture.get(2L,TimeUnit.SECONDS));// 指定超时时间
    // System.out.println(completableFuture.join()); // 都可以获取结果,但是jion在编译期间不会去检查是否有异常

    // 暂停几秒钟线程
    // try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

    // getNow:立即获取结果不阻塞,如果此时未计算完成,直接返回xxx,计算完成则返回结果
    // System.out.println(completableFuture.getNow("xxx"));

    // complete:是否打断get方法立即返回括号值
    System.out.println(completableFuture.complete("completeValue")+"\t"+completableFuture.get());
}

2.对计算结果进行处理

thenApply:计算结果存在依赖关系,这两个线程串行化,如果当前步错(存在异常),不走下一步

handle:计算结果存在依赖关系,这两个线程串行化,如果当前步错(存在异常),也可以走下一步,根据带的异常参数可以进一步处理

public static void main(String[] args){
    ExecutorService threadPool = Executors.newFixedThreadPool(3);

    CompletableFuture.supplyAsync(() ->{
        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("111");
        return 1;
    },threadPool).thenApply(f -> {
        //            int i = 10/0;
        System.out.println("222");
        return f + 2;
    }).thenApply(f -> {
        System.out.println("333");
        return f + 3;
    }).whenComplete((v,e) -> {
        if (e == null) {
            System.out.println("----计算结果: " + v);
        }
    }).exceptionally(e -> {
        e.printStackTrace();
        System.out.println(e.getMessage());
        return null;
    });

    System.out.println(Thread.currentThread().getName()+"----主线程先去忙其它任务");

    threadPool.shutdown();
}

Java线程的创建方式以及线程池的使用_第9张图片

public static void main(String[] args)
    {
        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        CompletableFuture.supplyAsync(() ->{
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("111");
            return 1;
        },threadPool).handle((f,e) -> {
            int i = 10/0;
            System.out.println("222");
            return f + 2;
        }).handle((f,e) -> {
            System.out.println("333");
            return f + 3;
        }).whenComplete((v,e) -> {
            if (e == null) {
                System.out.println("----计算结果: " + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        });

        System.out.println(Thread.currentThread().getName()+"----主线程先去忙其它任务");

        threadPool.shutdown();
    }

Java线程的创建方式以及线程池的使用_第10张图片

3.对计算结果进行消费

thenRun:任务A执行完执行B,并且B不需要A的结果

thenAccept:接受任务的处理结果,并消费处理,无返回结果,任务A执行完执行B,B需要A的结果,但是任务B无返回值

thenApply:任务A执行完执行B,B需要A的结果,同时任务B有返回值

public static void main(String[] args)
    {
        CompletableFuture.supplyAsync(() -> {
            return 1;
        }).thenApply(f ->{
            return f + 2;
        }).thenApply(f ->{
            return f + 3;
        }).thenAccept(System.out::println); // 6
        // }).thenAccept(r-> System.out.println(r));

    System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenRun(() -> {}).join());
        System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenAccept(r -> System.out.println(r)).join());
        System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenApply(r -> r + "resultB").join());
}

Java线程的创建方式以及线程池的使用_第11张图片

4.对计算速度进行选用

applyToEither:谁快用谁

public static void main(String[] args)
{
    CompletableFuture<String> playA = CompletableFuture.supplyAsync(() -> {
        System.out.println("A come in");
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        return "playA";
    });

    CompletableFuture<String> playB = CompletableFuture.supplyAsync(() -> {
        System.out.println("B come in");
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        return "playB";
    });

    CompletableFuture<String> result = playA.applyToEither(playB, f -> {
        return f + " is winer";
    });

    System.out.println(Thread.currentThread().getName()+"\t"+"-----: "+result.join());
}

Java线程的创建方式以及线程池的使用_第12张图片

5.对计算结果进行合并

thenCombine:两个CompletionStage任务都完成后,最终能把两个任务的结果一起交给thenCombine来处理,先完成的先等着,等待其他分支任务

public static void main(String[] args)
{
    CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
        System.out.println(Thread.currentThread().getName() + "\t ---启动");
        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 10;
    });

    CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
        System.out.println(Thread.currentThread().getName() + "\t ---启动");
        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 20;
    });

    CompletableFuture<Integer> result = completableFuture1.thenCombine(completableFuture2, (x, y) -> {
        System.out.println("-----开始两个结果合并");
        return x + y;
    });

    System.out.println(result.join());
}

Java线程的创建方式以及线程池的使用_第13张图片

链式调用:

Java线程的创建方式以及线程池的使用_第14张图片

CompletableFuture线程池运行选择

Java线程的创建方式以及线程池的使用_第15张图片

代码演示:

public static void main(String[] args)
{
    ExecutorService threadPool = Executors.newFixedThreadPool(5);

    try
    {
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("1号任务" + "\t" + Thread.currentThread().getName());
            return "abcd";
        },threadPool).thenRunAsync(() -> {
            try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("2号任务" + "\t" + Thread.currentThread().getName());
        }).thenRun(() -> {
            try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("3号任务" + "\t" + Thread.currentThread().getName());
        }).thenRun(() -> {
            try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("4号任务" + "\t" + Thread.currentThread().getName());
        });
        System.out.println(completableFuture.get(2L, TimeUnit.SECONDS));
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        threadPool.shutdown();
    }
}

Java线程的创建方式以及线程池的使用_第16张图片

四、线程的创建方式四

/**
  * 4.通过java提供的工具类Executors创建线程池,不推荐,会存在问题,推荐使用自定义线程池的方式
*/
@Test
void test4(){
    // 创建单个线程的线程池
    ExecutorService executorService = Executors.newSingleThreadExecutor();

    executorService.submit(new Runnable() {
        @Override
        public void run() {
            System.out.println("通过Executors创建线程1");
        }
    });

    executorService.submit(()->{
        System.out.println("通过Executors创建线程2");
    });

    // 销毁线程池
    executorService.shutdown();
    // executorService.shutdownNow();

}

Java线程的创建方式以及线程池的使用_第17张图片

销毁线程池shutdown和shutdownNow的区别

Java线程的创建方式以及线程池的使用_第18张图片

自定义线程池

哔哩哔哩链接:https://www.bilibili.com/video/BV15b4y117RJ?p=67&vd_source=7c5f1f4c039688f19024d50ef51aaed1

  1. corePoolSize 核心线程数目 - 池中会保留的最多线程数
  2. maximumPoolSize 最大线程数目 - 核心线程+救急线程的最大数目
  3. keepAliveTime 生存时间 - 救急线程的生存时间,生存时间内没有新任务,此线程资源会释放
  4. unit 时间单位 - 救急线程的生存时间单位,如秒、毫秒等
  5. workQueue 阻塞队列- 当没有空闲核心线程时,新来任务会加入到此队列排队,队列满会创建救急线程执行任务
  6. threadFactory 线程工厂 - 可以定制线程对象的创建,例如设置线程名字、是否是守护线程等
  7. handler 拒绝策略 - 当所有线程都在繁忙,workQueue 也放满时,会触发拒绝策略
    1. 抛异常 java.util.concurrent.ThreadPoolExecutor.AbortPolicy
    2. 由调用者(一般为main主线程)执行任务 java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
    3. 丢弃任务 java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
    4. 丢弃最早排队任务 java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy

Java线程的创建方式以及线程池的使用_第19张图片

@Test
public void task(){
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
        2, // 核心线程数
        3, // 最大线程数,核心线程数 + 救急线程数
        0,   // 空闲存活时间
        TimeUnit.SECONDS, // 时间单位
        new ArrayBlockingQueue<>(2), // 工作队列中最多2个任务
        r -> new Thread(r, "myThread" + new AtomicInteger(1).getAndIncrement()), // 线程工厂
        new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
    );

    threadPoolExecutor.submit(()->{
        System.out.println("自定义线程池");
    });
}

ThreadPoolExecutor是JDK中的线程池类,继承自Executor, Executor 顾名思义是专门用来处理多线程相关的一个接口,所有线程相关的类都实现了这个接口,里面有一个execute()方法,用来执行线程,线程池主要提供一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁的额外开销,提高了响应的速度。相关的继承实现类图如下。

Java线程的创建方式以及线程池的使用_第20张图片

一、线程池接口:ExecutorService为线程池接口,提供了线程池生命周期方法,继承自Executor接口,ThreadPoolExecutor为线程池实现类,提供了线程池的维护操作等相关方法,继承自AbstractExecutorService,AbstractExecutorService实现了ExecutorService接口。

二、线程池的体系结构:

java.util.concurrent.Executor 负责线程的使用和调度的根接口

​ |–ExecutorService 子接口: 线程池的主要接口

​ |–ThreadPoolExecutor 线程池的实现类

​ |–ScheduledExceutorService 子接口: 负责线程的调度

​ |–ScheduledThreadPoolExecutor : 继承ThreadPoolExecutor,实现了ScheduledExecutorService

工具类 : Executors

Executors为线程池工具类,相当于一个工厂类,用来创建合适的线程池,返回ExecutorService类型的线程池。有如下方法。

ExecutorService newFixedThreadPool() : 创建固定大小的线程池

ExecutorService newCachedThreadPool() : 缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。

ExecutorService newSingleThreadExecutor() : 创建单个线程池。 线程池中只有一个线程

ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程,可以延迟或定时的执行任务

其中AbstractExecutorService是他的抽象父类,继承自ExecutorService,ExecutorService 接口扩展Executor接口,增加了生命周期方法。

创建一个制定大小的线程池,Exectuors工厂实际上就是调用的ExectuorPoolService的构造方法,传入默认参数。

哔哩哔哩链接:https://blog.csdn.net/weixin_43168010/article/details/97613895

注意:使用工具类Executors创建线程池会存在问题,如newCachedThreadPool方法,核心线程数为0,而最大线程数为整数最大值,即如果任务过多会创建大量的救急线程,导致内存溢出。

Java线程的创建方式以及线程池的使用_第21张图片

再比如newFixedThreadPool方法,它创建了一个存放整数最大值的任务队列,也可能导致内存溢出。

Java线程的创建方式以及线程池的使用_第22张图片

哔哩哔哩链接:https://www.bilibili.com/video/BV1T44y1H7pu?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1

newSingleThreadExecutor

Java线程的创建方式以及线程池的使用_第23张图片

newFixedThreadPool

Java线程的创建方式以及线程池的使用_第24张图片

newCachedThreadPool

Java线程的创建方式以及线程池的使用_第25张图片

newScheduledThreadPool

Java线程的创建方式以及线程池的使用_第26张图片

建议

Java线程的创建方式以及线程池的使用_第27张图片

Spring下的自定义线程池

ThreadPoolTaskExecutor是spring包下的,是spring为我们提供的线程池类

public ThreadPoolTaskExecutor taskExecutorDing() {
        ThreadPoolTaskExecutor taskExecutorDing = new ThreadPoolTaskExecutor();
        // 固定线程数
        taskExecutorDing.setCorePoolSize(10);
        // 最大线程数
        taskExecutorDing.setMaxPoolSize(50);
        // 指定任务队列数量
        taskExecutorDing.setQueueCapacity(300);
        // 线程空闲时间
        taskExecutorDing.setKeepAliveSeconds(60);
        // 是否允许超时
        taskExecutorDing.setAllowCoreThreadTimeOut(true);
        // 线程名称前缀
        taskExecutorDing.setThreadNamePrefix("taskExecutorDing--");
        /** 设置拒绝策略
         * AbortPolicy
         * -- 默认,当任务添加到线程池中被拒绝时(固定线程池、最大线程数以及任务队列都放满),它将抛出 RejectedExecutionException 异常。
         * CallerRunsPolicy
         * -- 当任务添加到线程池中被拒绝时(固定线程池、最大线程数以及任务队列都放满),由调用者(一般为main主线程)处理被拒绝的任务。
         * DiscardOldestPolicy
         * -- 当任务添加到线程池中被拒绝时(固定线程池、最大线程数以及任务队列都放满),线程池会放弃等待队列中最旧的未处理任务,然后将被拒绝的任务添加到等待队列中(最后面)。
         * DiscardPolicy
         * -- 当任务添加到线程池中被拒绝时(固定线程池、最大线程数以及任务队列都放满),线程池将丢弃被拒绝的任务。
         */
        taskExecutorDing.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 线程池关闭时需等待所有的子任务执行完成才销毁对应的bean
        taskExecutorDing.setWaitForTasksToCompleteOnShutdown(true);
        // 等待的时间
        taskExecutorDing.setAwaitTerminationSeconds(60);
        // 初始化线程池
        taskExecutorDing.initialize();

        return taskExecutorDing;
    }

五、守护线程

Java线程的创建方式以及线程池的使用_第28张图片

@Test
public void isDaemon(){
    Thread thread = new Thread(() -> {
        // 守护线程内创建的线程也为守护线程
        Thread thread_inner = new Thread(() -> {
            AtomicInteger atomicInteger = new AtomicInteger(1);
            while (true){
                System.out.println(atomicInteger.getAndIncrement());
            }
        },"thread_inner");
        thread_inner.start();
        System.out.println(thread_inner.getName() + "\t" +thread_inner.isDaemon());
    }, "myThread");
    thread.setDaemon(true); // 设置为守护线程
    thread.start();
    System.out.println(thread.getName() + "\t" +thread.isDaemon());
    System.out.println(Thread.currentThread().getName());
}

Java线程的创建方式以及线程池的使用_第29张图片

六、线程常用调度方法

哔哩哔哩链接:https://www.bilibili.com/video/BV1Za411C7zN?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1

Java线程的创建方式以及线程池的使用_第30张图片

Java线程的创建方式以及线程池的使用_第31张图片

Java线程的创建方式以及线程池的使用_第32张图片

七、线程池execute和submit的区别

Java线程的创建方式以及线程池的使用_第33张图片

八、为什么启动线程是调用start方法,而不是run方法

哔哩哔哩链接:https://www.bilibili.com/video/BV1h44y1p7xe?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1

Java线程的创建方式以及线程池的使用_第34张图片

Java线程的创建方式以及线程池的使用_第35张图片

九、为什么使用线程池

Java线程的创建方式以及线程池的使用_第36张图片

十、线程池执行流程

Java线程的创建方式以及线程池的使用_第37张图片

Java线程的创建方式以及线程池的使用_第38张图片

十一、 CountDownLatch的使用

哔哩哔哩链接:https://www.bilibili.com/video/BV1nr4y1a72f?spm_id_from=333.999.0.0&vd_source=7c5f1f4c039688f19024d50ef51aaed1
Java线程的创建方式以及线程池的使用_第39张图片
Java线程的创建方式以及线程池的使用_第40张图片

@Test
public void countdownlatch(){
    final int THREAD_NUM = 5;
    // 创建固定线程数的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(THREAD_NUM);
    // 如果有n个子线程,我们就指定CountDownLatch的计数器为n
    final CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM);
    // 提交任务到线程池
    for (int i = 0; i< THREAD_NUM; i++) {
        executorService.execute(() -> {
            try {
                //模拟每个线程处理业务,耗时一秒钟
                System.out.println("子线程:" +Thread.currentThread() . getName() + "开始执行");
                //模拟每个线程处理业务,耗时一秒钟
                TimeUnit.SECONDS.sleep( 1);
                System. out.println("子线程:" +Thread.currentThread().getName() +"执行完成");
                //当前线程调用此方法,则计数减一
                countDownLatch.countDown();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });
    }
    // 阻塞当前线程(此处为main线程),直到计数器的值为0,main线程才开始处理
    try {
        countDownLatch.await();
        System.out.println("当前线程:" + Thread.currentThread().getName() 
                           + "此时countDownLatch:" + countDownLatch.getCount());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 销毁线程池
    executorService.shutdown();
}

Java线程的创建方式以及线程池的使用_第41张图片

十二、喜欢请关注我

至此,我们的Java线程的创建方式以及线程池的使用就讲解完成了。喜欢我的话可以关注我的微信公众号我爱学习呀嘻嘻 ,不定期分享各类资源哦。

image-20211108230322493

你可能感兴趣的:(java,jvm,开发语言)