多线程的几种创建方式

最新推荐文章于 2022-10-16 13:16:25 发布
最新推荐文章于 2022-10-16 13:16:25 发布
阅读量213 收藏 1
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdaujsj1/article/details/104537091
版权

1. 继承Thread 重写run() 方法

package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description:
 */
@Slf4j
public class Thread01 extends Thread{
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            log.error("创建线程异常：{}",e);
        }
        log.info("Thread01-当前线程：{}", Thread.currentThread());
    }
}


package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) {
        log.info("主线程开始。。。");
        Thread01 thread01 = new Thread01();
        //异步化
        new Thread(thread01).start();
        log.info("主线程结束......");
    }

}

运行结果：
在这里插入图片描述

2.实现Runable 重写run()方法

package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description:
 */
@Slf4j
public class Thread02 implements Runnable {
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            log.error("创建线程异常：{}",e);
        }
        log.info("Thread02-当前线程：{}"+Thread.currentThread());
    }
}


package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) {
        log.info("主线程开始。。。");
        new Thread(new Thread02()).start();
        log.info("主线程结束......");
    }

}

运行结果：
在这里插入图片描述

3. 使用Callable

以上没法使用线程里面的返回值。而使用Callable可以

package com.xiepanpan.locks.lockstest.service;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description:
 */
public class Thread03 implements Callable<String> {
    @Override
    public String call() throws Exception {
        TimeUnit.SECONDS.sleep(3);
        return "OK";
    }
}


package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        log.info("主线程开始。。。");
        FutureTask<String> task = new FutureTask<>(new Thread03());
        new Thread(task).start();
        String s = task.get();
        log.info("主线程哈哈哈。。。。");
        log.info("异步获取到的结果是：{}",s);
        log.info("主线程结束......");
    }

}


    log.info("异步获取到的结果是：{}",s);

要获取s的结果 此时主线程处于等待状态 所以主线程结束 最后执行

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
Future提供了三种功能：
　　1）判断任务是否完成；
　　2）能够中断任务；
　　3）能够获取任务执行结果。
FutureTask是Future和Runable的实现



package java.util.concurrent;


public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

4. ExecutorService 使用线程池

为什么要使用线程池

假如不使用线程池

package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        log.info("主线程开始。。。");

        for (int i=0;i<10;i++) {
            new Thread(()->{
                log.info("当前线程开始:{}",Thread.currentThread());
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    log.error("线程异常：{}",e);
                }
                log.info("当前线程结束: {}",Thread.currentThread());
            }).start();
        }
        log.info("主线程结束......");
    }

}

执行结果：
在这里插入图片描述
循环十次要创建十个线程

使用线程池

package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.UUID;
import java.util.concurrent.*;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        log.info("主线程开始。。。");
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        for (int i=0;i<10;i++) {
            Thread thread = new Thread(() -> {
                log.info("当前线程开始:{}", Thread.currentThread());
                try {
                    TimeUnit.SECONDS.sleep(5);
                    int  j= 5/0;
                } catch (InterruptedException e) {
                    log.error("线程异常：{}", e);
                }
                log.info("当前线程结束: {}", Thread.currentThread());
            });
            给线程池提交任务
            threadPool.submit(thread);
        }
        log.info("主线程结束......");
    }

}

执行结果：
在这里插入图片描述

可以看到 只用两个线程再执行
使用线程池控制系统资源，防止线程资源耗尽

线程池种类

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
Java通过Executors提供四种线程池，分别为：

  • newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  • newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  • newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
  • newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

默认的线程池里面的Queue是一个无界队列。
极限情况。线程全部放进队列。无界队列撑爆内存。
ThreadPool：拒绝策略。四种：自己总结;默认出异常。

使用线程池有个问题 我写了个int j= 5/0; 但不报错 任务交给线程池，出现异常无法感知。

5 CompletableFuture（异步编排）

Future接口可以构建异步应用，但依然有其局限性。它很难直接表述多个Future 结果之间的依赖性。实际开发中，我们经常需要达成以下目的：

  • 将多个异步计算的结果合并成一个
  • 等待Future集合中的所有任务都完成
  • Future完成事件（即，任务完成以后触发执行动作）
package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.UUID;
import java.util.concurrent.*;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        log.info("主线程开始。。。");
        ExecutorService threadPool = Executors.newFixedThreadPool(2);

        CompletableFuture.supplyAsync(()->{
            log.info("当前线程开始: {}",Thread.currentThread());
            String uuid = UUID.randomUUID().toString();
//            uuid+=10/0;
            log.info("当前线程结束：{}",Thread.currentThread());
            return uuid;
        },threadPool).thenApply((r)->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                log.error("线程睡眠异常:{}",e);
            }
            log.info("上一步执行结果：{}",r);
            int i = 10/0;
            return r+10/0;
        }).whenComplete((r,e)->{
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException ex) {
                log.error("线程睡眠异常:{}",ex);
            }
            log.info("最终结果：{}",r);
            log.error("异常信息：{}",e);
        });
        log.info("主线程结束......");

    }

}

执行结果：
在这里插入图片描述

有异常就输出了
实际使用：

package com.xiepanpan.locks.lockstest.service;

import lombok.extern.slf4j.Slf4j;

import java.util.UUID;
import java.util.concurrent.*;

/**
 * @author: xiepanpan
 * @Date: 2020/2/27
 * @Description: 多线程测试类
 */
@Slf4j
public class ThreadTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        log.info("主线程开始。。。");

        ExecutorService threadPool = Executors.newFixedThreadPool(10);    
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            log.info("查询商品基本数据...");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                log.error("线程睡眠异常:{}",e);
            }
            return "华为";
        }, threadPool).whenComplete((r, e) -> {
            log.info("结果是：{}", r);
        });
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            log.info("查询商品属性数据...");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                log.error("线程睡眠异常:{}",e);
            }
            return "金色";
        }, threadPool).whenComplete((r, e) -> {
            log.info("结果是：{}", r);
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            log.info("查询商品营销数据...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                log.error("线程睡眠异常:{}",e);
            }
            return "满199减100";
        }, threadPool).whenComplete((r, e) -> {
            log.info("结果是：{}" + r);
        });
        CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);
        //线程插队
        allOf.join();
        log.info("所有人都完事了：{}",future1.get()+future2.get()+future3.get());

    }

}

这个方法5秒完事 一个线程的话需要10秒

以后异步任务的编程模式: CompletableFuture.supplyAsync(()->{},pool).whenComplete()

CompletableFuture的方法：
thenApply

当前阶段正常完成以后执行，而且当前阶段的执行的结果会作为下一阶段的输入参数。thenApplyAsync默认是异步执行的。这里所谓的异步指的是不在当前线程内执行。
thenApply相当于回调函数（callback）（如ajax的success,error等回调）

thenAccept与thenRun

thenAccept和thenRun都是无返回值的。

如果说thenApply是不停的输入输出的进行生产，那么thenAccept和thenRun就是在进行消耗。它们是整个计算的最后两个阶段。
同样是执行指定的动作，同样是消耗，二者也有区别：

  • thenAccept接收上一阶段的输出作为本阶段的输入
  • thenRun根本不关心前一阶段的输出，根本不不关心前一阶段的计算结果，因为它不需要输入参数
thenAccept与thenAccpetAsync
1、thenAccept只接受上一步的结果

          thenAccept(r){
              r:上一步的结果
         }
2、	thenApply(r){
              r：把上一步的结果拿来进行修改再返回，
          }

3、thenAccpet(){} 上一步结果1s+本次处理2s=3s
         
4、thenAccpetAsync(){} 上一步1s+异步2s = 最多等2s
thenCombine整合两个计算结果

在这里插入图片描述

whenComplete
allOf()
想上岸的小写
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript多线程的实现方法
12-11
注：以下内容基于IE中GIF的onload事件的基础上，故所有测试IE only 需要用到的几个图片 先看一个简单的事实： 代码如下:[removed] var img=new Image(); img.src=”attachment/1178365293_0.gif”; img.onload=function() { alert(“如要关闭请按住ESC键不放，并点击关闭按钮”); } [removed] 如果不出所料的话你的IE应该弹出一大堆alert提示窗口了。注意是“一大堆”！ 原因很简单：IE对多帧GIF的onload事件重复执行，即每播放完
Java8函数式编程 —— CompletableFuture
zl_momomo的博客
11-26 897
前言 可完成的Future 对于1.5提供的Future接口。有一定的局限性，很难直接表述多个future之间的依赖性。比如对于结果的获取只能通过阻塞或者轮询的方式获得，这违背了异步编程的初衷。 下面通过一个简单的例子说明CompletableFuture的使用。 例子 将List中元素，异步方式全部小写转大写 List&lt;String&gt; list = ne...
JDK8-11-CompletableFuture（4）- supplyAsync 方法使用
sql2008help的博客
10-16 1004
生活中有一些多线程的例子，例如顾客去餐馆点餐，大致可以分为如下几个步骤：1.顾客进入餐厅2.顾客开始点餐3.厨师按照顾客所选菜品开始炒菜4.厨师打饭（假设没有服务员）5.顾客开始吃饭，用于模拟耗时和打印当前时间戳和线程信息从执行结果中可以看出，main线程处理顾客相关动作，ForkJoinPool.commonPool-worker-1 线程处理厨师相关动作，从时间戳可以看出顾客玩手机和厨师开始炒菜都是1665891660537 ，符合异步处理场景。
如何合理设置线程池大小
diaojin6880的博客
09-21 1054
要想合理的配置线程池的大小，首先得分析任务的特性，可以从以下几个角度分析： 任务的性质：CPU密集型任务、IO密集型任务、混合型任务。 任务的优先级：高、中、低。 任务的执行时间：长、中、短。 任务的依赖性：是否依赖其他系统资源，如数据库连接等。 性质不同的任务可以交给不同规模的线程池执行。 对于不同性质的任务来说，CPU密集型任务应配置尽可能...
【Java 8 新特性】Java CompletableFuture supplyAsync()
猫巳的博客
05-18 3万+
Java CompletableFuture supplyAsync与 thenApply() 一起使用自定义执行器 Executor与 whenComplete() 一起使用与流(Stream)一起使用参考文献 在此页面上，我们将提供Java CompletableFuture.supplyAsync()示例。 supplyAsync()是Java 8中引入的CompletableFuture静态方法。 方法supplyAsync()完成在ForkJoinPool.commonPool()或给定的Exec
java 创建线程的几种方式
08-31
在Java编程语言中，创建线程是实现多任务并发处理的关键。本文将详细阐述两种主要的线程创建方式，以及它们的特点和使用场景。...希望本文提供的内容能对你的学习和工作有所帮助，并激发你对Java多线程更深入的探索。
Java 实现多线程的几种方式汇总
09-02
在Java中，实现多线程主要有以下三种方式： 1. **继承Thread类**： 当一个类继承了`Thread`类，那么这个类就是一个线程类。你需要重写`Thread`类的`run()`方法，将线程执行的代码放入`run()`方法内。例如，`...
python线程的几种创建方式详解
12-31
Python3 线程中常用的两个模块为： _thread threading(推荐使用) 使用Thread类创建 import threading from time import sleep,ctime def sing(): for i in range(3): print(正在唱歌...%d%i) sleep(1) def ...
c#使用多线程的几种方式示例详解
09-04
以下是对标题和描述中提到的四种使用多线程方式的详细解释： 1. **不带参数且无返回值的线程** 这是最基础的创建线程的方式，使用`ThreadStart`委托。在这个例子中，我们创建一个`ThreadStart`实例，并将要执行的...
详解Python并发编程之创建多线程的几种方法
09-18
在Python中，创建多线程主要有两种方法：函数式和面向对象式。 1. **学会使用函数创建多线程** 在Python中，我们可以使用内置的`threading`模块的`Thread`类来创建线程。`Thread`类的构造函数`Thread(target=func,...
Java8新特性整理之CompletableFuture：组合式、异步编程（七）
热门推荐
一大三千的博客
02-13 6万+
使用CompletableFuture构建异步应用 Future 接口的局限性 Future接口可以构建异步应用，但依然有其局限性。它很难直接表述多个Future 结果之间的依赖性。实际开发中，我们经常需要达成以下目的： 将两个异步计算合并为一个——这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果。 等待 Future 集合中的所有任务都完成。 仅等待 Future集合中最快...
js 异步的几种方式 （简述）
qq_41764462的博客
12-03 1137
异步编程 随着计算机的不断发展，用户对计算机应用的要求越来越高，需要提供更多、更只能、响应速度更快的功能。这就离不开异步编程的话题。同时，随着互联网时代的崛起，网络应用要求能够支持更多的并发量，这显然也要用到大量的异步编程。 什么是异步 有异步就不得步提另一个概念：同步，这样的理解是错误的，咱们不能以字面的意思去理解它。同步，英文名叫做 Syncjrpmozation 。它是指同一时间只能做一件...
CompletableFuture 详解（二）：supplyAsync / runAsync 实现原理 源码分析
tongtest的博客
07-25 4万+
前面CompletableFuture详解（一）：基本概念及用法讲了CompletableFuture的使用，从这篇开始，我们深入了解CompletableFuture的实现，以便于大家更深入的理解CompletableFuture是如何运行的，这也有利于大家正确地使用CompletableFuture。 本篇主要介绍 supplyAsync和runAsync的实现。 1、supplyAsync的实现 我们主要看入参为Supplier的版本。因为另外一个版本的supplyAsync函数，除了增加了自定
java8新特性CompletableFuture异步编程使用 和 并行流parallel，CompletableFuture与Executors线程池的使用与区别
我是guyue，guyue就是我O(∩_∩)O
12-04 4073
带有示例的Java CompletableFuture教程| CalliCoder https://www.callicoder.com/java-8-completablefuture-tutorial/ 并行流parallel，CompletableFuture与Executors线程池的使用与区别 - R_P_J的博客 - CSDN博客 https://blog.csdn.net/r...
CompletableFuture的async后缀函数与不带async的函数的区别
英悟的博客
06-03 9451
async函数 thenApply thenApplyAsync thenAccept thenAcceptAsync whenComplete whenCompleteAsync 等等等等 不带async的函数的动作比较复杂 只要下面两个例子看懂了，就行了。 public class Lession07 { private final static Logger...
java8 supplyasync_【新特性】java8新特性
weixin_39992312的博客
02-27 1249
java8新特性异步编程CompletableFuture 实现异步编程supplyAsync 有返回值CompletableFuture f1 = CompletableFuture.supplyAsync(() -> "hello");runAsync参数是Runable没有返回值CompletableFuture runAsync = CompletableFuture.runAsy...
CompletableFuture 使用详解
江城宴的博客
12-22 7199
CompletableFuture 使用详解 1、 runAsync 和 supplyAsync方法 CompletableFuture 提供了四个静态方法来创建一个异步操作。 public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture&...
SpringBoot实践（二十二）：一文搞懂多线程和线程池使用
叶子叶来
07-11 618
当我们完成业务逻辑开发，把jar包发布到环境中启动，就是在该主机上拉起了1个进程，该进程会进行系统调用监听端口请求，返回计算结果，同一代码段（或者方法），比如用户登录方法在同时刻可以有多个请求过来，每个请求就是1个处理线程，线程是CPU的最小处理单元，可以把进程比作工厂，线程是流水线，工厂包含原材料、启动/关闭多个流水线、输出产物。......
CompletableFuture
散步的博客
04-08 345
Future和Callable接口： Future接口定义了操作异步任务执行一些方法，如获取异步任务的执行结果，取消任务的执行，判断任务是否被取消，判断任务执行是否完毕等。 Callable 接口中定义了需要有返回的任务需要实现的方法 比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后， 主线程就去做其他事情了，过了一会才去获取子任务的执行结果。 FutureTask： future接口架构： get()阻塞 一旦调用get()方法，不管是否计算完成都会导致阻塞 isDone
创建多线程的方式有几种？
最新发布
09-13
在Python中，有两种常用的创建多线程的方式： 1. 使用threading模块创建线程。可以通过创建Thread对象并将一个函数作为目标来创建新线程。例如： ``` import threading def my_function(): # 代码块 my_thread ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值