Java程序员必备技能多线程&任务组合异步操作

最新推荐文章于 2024-03-05 17:09:40 发布

杨星辰Red

最新推荐文章于 2024-03-05 17:09:40 发布

阅读量89

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/oemciemcier/article/details/134639796

版权

线程回顾

初始化线程方式

继承Thread
实现runnable接口
实现callable接口+FutureTask（可以拿到返回结果，可以处理异常）
线程池

package com.atguigu.gulimall.search.Thread;

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main 方法开始了");
        Thread01 thread01 = new Thread01();
        thread01.start();
        System.out.println("main 结束了");
    }
    public static class Thread01 extends java.lang.Thread {
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果"+i);
        }
    }
}

package com.atguigu.gulimall.search.Thread;

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main 方法开始了");
        new Thread(new Runnable01()).start();
        System.out.println("main 结束了");
    }
    public static class Runnable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果"+i);
        }
    }
}

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        System.out.println("main 方法开始了");
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        //阻塞等待，待整个线程执行完成，获取返回结果
        Integer data = futureTask.get();
        System.out.println("结果："+data);
        System.out.println("main 结束了");
    }
    public static class Callable01 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程"+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果"+i);
            return i;
        }
    }
}

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    //创建一个线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("main 方法开始了");
        //将任务提交给线程池
        executorService.execute(new Runnable01());
        System.out.println("main 结束了");
    }
    public static class Runnable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程"+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果"+i);
        }
    }
}

利弊

方式一和方式二主进程无法获取线程的运算结果，不适合当前场景
方式三主进程可以获取线程的运算结果，但是不利于控制服务器中的线程资源，可以导致服务器资源耗尽
方式四通过如下两种方式初始化线程池

线程池

为什么要用线程池

降低资源的消耗
1. 通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
提高响应速度
1. 因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行
提高线程的客观理性
1. 线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销，无线的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

线程池七大核心参数

core:核心线程数，代表这个线程池永远都会有5个线程一直存在
maxPoolSize:最大线程数，表示这个线程池最大可以有多少个线程
keepAliveTime:空闲时间，当最大线程数-核心线程数剩下的空闲多长时间就会被释放掉
unit：空闲时间单位
workQueue：当超过5个线程任务进入后，会被当道这个队列中去，然后其他线程执行完成后，在从这个队列中取线程执行
threadFactory：创建线程的工厂模式
handler：拒绝策略，当队列中放入的线程满了后，会采用什么样的策略，来处理没有存放斤队列中的线程

ThreadPoolExecutor threadPoolExecutor = 
new ThreadPoolExecutor(5,200,60,
TimeUnit.MINUTES,new LinkedBlockingDeque<>(10000),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler){}

线程池类型

new ThreadPoolExecutor();普通线程池并且手动设置参数
Executors.newCachedThreadPool();核心是0，所有都可以回收
Executors.newFixedThreadPool(int size);固定大小,core=max,都不可以回收
Executors.newScheduledThreadPool();定时任务的线程池
Executors.newSingleThreadExecutor();单线程的线程池，只有一个核心和很大的队列Integer.max长度，所有进来的任务都会放到队列中，然后一条一条的从队列中拿任务执行。

异步编排

RunAsync（无返回值的）

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);
    public static void main(String[] args) {
        System.out.println("thread---  start ---");
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("线程ID"+Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("执行结果：" + i);
        }, executor);

        System.out.println("thread--- end ---");
    }
}

supplyAsync（有返回值的）

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("thread---  start ---");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程ID" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("执行结果：" + i);
            return i;
        }, executor);
        //调用get的时候这里会阻塞等待结果
        Integer integer = future.get();
        System.out.println("结果："+integer);
        System.out.println("thread--- end ---");
    }
}

计时完成回调方法

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("thread---  start ---");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程ID" + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("执行结果：" + i);
            return i;
        }, executor).whenComplete((res, exception) -> {
            //当上面的线程执行完成后，回调到这里，并且可以获取结果和异常，但是没有办法修改返回数据
            System.out.println("执行成功结果：" + res + "  执行失败异常" + exception);
        }).exceptionally((exception)->{
            //如果异常了，这里可以感知到异常 在做处理，可以修改返回数据
            return 10;
        });

        System.out.println("thread--- end ---"+future.get());
    }
}

handle完成回调方法

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("thread---  start ---");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程ID" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("执行结果：" + i);
            return i;
        }, executor).handle((res,exception)->{
            //使用handle就可以之间return 你的值，如果报错了也可以直接return你需要的值
            System.out.println("执行成功:+"+res+"  执行失败+"+exception);
            if (exception!=null){
                return 10;
            }else{
                return res;
            }
        });

        System.out.println("thread--- end ---"+future.get());
    }
}

线程串行化

A线程执行完成后，执行B线程，B线程不需要A线程的结果

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void main(String[] args){
        System.out.println("thread---  start ---");
        CompletableFuture.supplyAsync(() -> {
            System.out.println("线程ID" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("执行结果：" + i);
            return i;
        }, executor).thenRunAsync(()->{
            System.out.println("我接受不到上面线程的结果");
        },executor);
        System.out.println("thread--- end ---");
    }
}

A线程执行完成后，B线程执行需要A线程的结果

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("thread---  start ---");
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程ID" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("执行结果：" + i);
            return i;
        }, executor).thenAcceptAsync((res) -> {
            System.out.println("我是B线程，我接收到A线程的结果：" + res);
        }, executor);
        System.out.println("thread--- end ---");
    }
}

A线程执行完成后，B线程需要获取到A线程的执行结果，B线程执行完成后返回给外界

package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("thread---  start ---");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程ID" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("执行结果：" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("我接受到了A的结果：" + res);
            return 10;
        });
        System.out.println("thread--- end --- B的结果"+future.get());
    }
}

两个线程任务组合

两线程都完成

两个都完成后，在进行处理任务三

thenCombine：组合两个future，获取两个future的返回结果，并返回当前任务的返回值
thenAcceptBoth：组合两个future，获取两个future任务的返回结果，然后处理任务，没有返回值。
runAfterBoth：组合两个future，不需要获取future的结果，只需要两个future处理完成任务后，处理该任务。

runAfterBothAsync不能拿到任务一和任务二的执行结果，直接执行任务三

//两个都完成后，在进行处理任务三
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务一开始");
    System.out.println("任务一结束");
    return 10;
}, executor);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务二开始");
    System.out.println("任务二结束");
    return "hello";
}, executor);
future1.runAfterBothAsync(future2,()->{
    System.out.println("任务三开始");
},executor);

thenAcceptBothAsync允许拿到任务一和任务二的执行结果

//两个都完成后，在进行处理任务三
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务一开始");
    System.out.println("任务一结束");
    return 10;
}, executor);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务二开始");
    System.out.println("任务二结束");
    return "hello";
}, executor);
future1.thenAcceptBothAsync(future2,(res1,res2)->{
    System.out.println("任务一返回值："+res1);
    System.out.println("任务二返回值："+res2);
    System.out.println("任务三执行开始......");
},executor);

thenCombineAsync既可以拿到任务一和任务二的返回值也可以将自己任务三的结果返回出去

//两个都完成后，在进行处理任务三
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务一开始");
    System.out.println("任务一结束");
    return 10;
}, executor);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务二开始");
    System.out.println("任务二结束");
    return "hello";
}, executor);
CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (res1, res2) -> {
    System.out.println("任务三开始");
    return res1 + res2;
}, executor);

System.out.println("任务三返回值："+future3.get());

两线程任意一个完成

两个线程任意一个线程执行结果，就执行第三个线程。

applyToEither：两个任务有一个执行完成，获取他的返回值，处理任务并有新的返回值，
acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
runAfterEither：两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。

runAfterEither：不需要获取任务一或者任务二的结果，直接执行

//两个任务有一个完成，就执行任务三
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务一开始");
    System.out.println("任务一结束");
    return 10;
}, executor);

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务二开始");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("任务二结束");
    return "hello";
}, executor);
future1.runAfterEitherAsync(future2,()->{
    System.out.println("任务三执行开始");
    System.out.println("任务三执行结束");
},executor);

acceptEitherAsync，任意一个任务执行完成后，任务三就开始执行，也可以拿到任务一和任务二谁先执行完成的结果

CompletableFuture<Object> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务一开始");
    System.out.println("任务一结束");
    return 10;
}, executor);

CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务二开始");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("任务二结束");
    return "hell0";
}, executor);
//注意，如果使用Either的话并且需要接受返回值，那么就需要线程一和线程二的返回值类型是一样的才行，否则会报错
//或者全部改成object
future1.acceptEitherAsync(future2, (res) -> {
    System.out.println("任务三执行开始");
    System.out.println("线程一或者线程二，谁先执行完成的结果是："+res);
    System.out.println("任务三执行结束");
}, executor);

applyToEither 两个任务有一个执行完成，获取他的返回值，处理任务并有新的返回值，

//两个任务有一个完成，就执行任务三
CompletableFuture<Object> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务一开始");
    System.out.println("任务一结束");
    return 10;
}, executor);

CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务二开始");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("任务二结束");
    return "hell0";
}, executor);
//注意，如果使用Either的话并且需要接受返回值，那么就需要线程一和线程二的返回值类型是一样的才行，否则会报错
//或者全部改成object
CompletableFuture<String> future3 = future1.applyToEitherAsync(future2, (res) -> {
    System.out.println("任务三执行开始");
    System.out.println("线程一或者线程二，谁先执行完成的结果是：" + res);
    System.out.println("任务三执行结束");
    return "30" + res;
}, executor);

System.out.println("任务三返回值："+future3.get());

N个线程任务组合

allOf：等待所有任务完成
anyOf：只要有一个任务完成

allOf：等待所有任务完成，再走下一行

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("获取商品图片");
    return "logo.jpg";
}, executor);
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("获取商品属性");
    return "黑色256G";
}, executor);
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("获取商品介绍");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "华为-遥遥领先.....";
}, executor);

CompletableFuture<Void> future = CompletableFuture.allOf(future1, future2, future3);
System.out.println("执行结束");

获取商品图片
获取商品属性
执行结束
获取商品介绍

anyOf：只要有一个任务完成，就走下一行

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("获取商品图片");
    return "logo.jpg";
}, executor);
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("获取商品属性");
    return "黑色256G";
}, executor);
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("获取商品介绍");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "华为-遥遥领先.....";
}, executor);

CompletableFuture<Object> future = CompletableFuture.anyOf(future1, future2, future3);
System.out.println("执行结束");

获取商品图片
获取商品属性
执行结束
获取商品介绍