扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >一文搞懂Java创建线程的五种方法
  • 760

0
分享到

一文搞懂Java创建线程的五种方法

2024-04-02 19:04:59 760人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录题目描述解题思路代码详解第一种 继承Thread类创建线程第二种：实现Runnable接口创建线程第三种：实现Callable接口，通过FutureTask包装器来创建Threa

题目描述

Java创建线程的几种方式

Java使用Thread类代表线程，所有线程对象都必须是Thread类或者其子类的实例。Java可以用以下5种方式来创建线程

  • 继承Thread类创建线程；
  • 实现Runnable接口创建线程；
  • 实现Callable接口，通过FutureTask包装器来创建Thread线程；
  • 使用ExecutorService、Callable(或者Runnable)、Future实现由返回结果的线程。
  • 使用CompletableFuture类创建异步线程，且是据有返回结果的线程。 jdk8新支持的

实现：使用这5种方式创建线程，体验其中的妙处。 

解题思路

继承Thread类创建线程

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extends Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。

实现Runnable接口创建线程

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口

实现Callable接口，通过FutureTask包装器来创建Thread线程

实现一个Callable接口(它是一个具有返回值的)

使用ExecutorService、Callable(或者Runnable)、Future实现由返回结果的线程

Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口：

Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口：

//创建固定数目线程的线程池。
public static ExecutorService newFixedThreadPool(int nThreads) ;
//创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newCachedThreadPool();
//创建一个单线程化的Executor。
public static ExecutorService newSingleThreadExecutor();
//创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize);

ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。

使用CompletableFuture类创建异步线程，且是据有返回结果的线程

Future模式的缺点

Future虽然可以实现获取异步执行结果的需求，但是它没有提供通知的机制，我们无法得知Future什么时候完成。

要么使用阻塞，在future.get()的地方等待future返回的结果，这时又变成同步操作。要么使用isDone()轮询地判断Future是否完成，这样会耗费CPU的资源。

CompletableFuture 介绍

JDK1.8新加入的一个实现类CompletableFuture，实现了Future, CompletionStage两个接口。

CompletableFuture中4个异步执行任务静态方法：

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }
    
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,Executor executor) {
    return asyncSupplyStage(screenExecutor(executor), supplier);
}
    
public static CompletableFuture<Void> runAsync(Runnable runnable) {
    return asyncRunStage(asyncPool, runnable);
}
    
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) {
    return asyncRunStage(screenExecutor(executor), runnable);
}

其中supplyAsync用于有返回值的任务，runAsync则用于没有返回值的任务。Executor参数可以手动指定线程池，否则默认ForkJoinPool.commonPool()系统级公共线程池

代码详解

第一种 继承Thread类创建线程

package cn.xiaoxuzhu.daily;

import java.util.concurrent.CountDownLatch;
 

 
 
public class ThreadDemo1 extends Thread {
    CountDownLatch countDownLatch;
 
    public ThreadDemo1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
 
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":my thread ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }
    }
 
    public static void main(String[] args) {
        // 第一种：使用extends Thread方式
        CountDownLatch countDownLatch1 = new CountDownLatch(2);
        for (int i = 0; i < 2; i++) {
            ThreadDemo1 myThread1 = new ThreadDemo1(countDownLatch1);
            myThread1.start();
        }
 
        try {
            countDownLatch1.await();
            System.out.println("thread complete...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

 
}

第二种：实现Runnable接口创建线程

package cn.xiaoxuzhu.daily;
 
import java.util.concurrent.CountDownLatch;
 

 
 
 
public class ThreadDemo2  implements Runnable{
    CountDownLatch countDownLatch;
 
    public ThreadDemo2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":my runnable ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }
    }
 
    public static void main(String[] args) {
        // 第二种：使用implements Runnable方式
        CountDownLatch countDownLatch2 = new CountDownLatch(2);
        ThreadDemo2 myRunnable = new ThreadDemo2(countDownLatch2);
        for (int i = 0; i < 2; i++) {
            new Thread(myRunnable).start();
        }
 
        try {
            countDownLatch2.await();
            System.out.println("runnable complete...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

第三种：实现Callable接口，通过FutureTask包装器来创建Thread线程

计算1~100的叠加

package cn.xiaoxuzhu.daily;
 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 

 
public class ThreadDemo3 implements Callable<Integer> {
 
    public static void main(String[] args) {
        ThreadDemo3 threadDemo03 = new ThreadDemo3();
        //1、用futureTask接收结果
        FutureTask<Integer> futureTask = new FutureTask<>(threadDemo03);
        new Thread(futureTask).start();
 
        //2、接收线程运算后的结果
        try {
            //futureTask.get();这个是堵塞性的等待
            Integer sum = futureTask.get();
            System.out.println("sum="+sum);
            System.out.println("-------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
 
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <101 ; i++) {
            sum+=i;
        }
        return sum;
    }
}

第四种：使用ExecutorService、Callable(或者Runnable)、Future实现返回结果的线程

package cn.xiaoxuzhu.daily;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 

 
 
public class ThreadDemo4 {
 
    static class MyCallable implements Callable<Integer> {
        private CountDownLatch countDownLatch;
 
        public MyCallable(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }
 
        public Integer call() {
            int sum = 0;
            try {
               
                for (int i = 0; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("线程执行结果："+sum);
                
            } finally {
                countDownLatch.countDown();
            }
            return sum;
        }
 
    }
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 第四种：使用使用线程池方式
        // 接受返回参数
        List<Future> resultItems2 = new ArrayList<Future>();
        // 給线程池初始化5個线程
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        CountDownLatch countDownLatch4 = new CountDownLatch(10);
 
        for (int i = 0; i < 10; i++) {
            MyCallable myCallable = new MyCallable(countDownLatch4);
            Future result = executorService.submit(myCallable);
            resultItems2.add(result);
        }
 
        // 等待线程池中分配的任务完成后才关闭(关闭之后不允许有新的线程加入，但是它并不会等待线程结束)，
        // 而executorService.shutdownNow();是立即关闭不管是否线程池中是否有其他未完成的线程。
        executorService.shutdown();
        try {
            countDownLatch4.await();
            Iterator<Future> iterator = resultItems2.iterator();
            System.out.println("----------------------");
            while (iterator.hasNext()) {
                try {
                    System.out.println("线程返回结果："+iterator.next().get());
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("callable complete...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

第五种：使用ComletetableFuture类创建异步线程，且是据有返回结果的线程

package cn.xiaoxuzhu.daily;
 
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
import org.junit.Test;
 

 
public class ThreadDemo5 {
 
    
    @Test
    public void completableFuture1(){
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("future1 finished!");
            return "future1 finished!";
        });
 
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("future2 finished!");
            return "future2 finished!";
        });
 
        CompletableFuture<Void> future3 = CompletableFuture.allOf(future1, future2);
        try {
            future3.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("future1: " + future1.isDone() + " future2: " + future2.isDone());
 
    }
 
    
    @Test
    public void test01() throws Exception {
        ExecutorService service = Executors.newFixedThreadPool(5);
        
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "xiaoxuzhu";
        }, service);
        CompletableFuture<Void> data = CompletableFuture.runAsync(() -> System.out.println("xiaoxuzhu"));
        
        future.whenComplete((x,y)-> System.out.println("有延迟3秒：执行当前任务的线程继续执行:"+x+","+y)); //执行当前任务的线程继续执行
        data.whenCompleteAsync((x,y)-> System.out.println("交给线程池另起线程执行:"+x+","+y)); // 交给线程池另起线程执行
        future.exceptionally(Throwable::toString);
        //System.out.println(future.get());
        
        //第二个线程依赖第一个的结果
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5).thenApply(x -> x);
 
        
        CompletableFuture<Integer> future2 = future1.handleAsync((x, y) -> x + 2);
        System.out.println(future2.get());//7
        
        future2.thenAccept(System.out::println);
        
        future2.thenRunAsync(()-> System.out.println("继续下一个任务"));
        
        CompletableFuture<Integer> future3 = future1.thenCombine(future2, Integer::sum);
        System.out.println(future3.get()); // 5+7=12
        
        future1.thenAcceptBothAsync(future2,(x,y)-> System.out.println(x+","+y)); //5,7
        
        CompletableFuture<Integer> future4 = future1.applyToEither(future2, x -> x);
        System.out.println(future4.get()); //5
        
        future1.acceptEither(future2, System.out::println);
        
        future1.runAfterEither(future,()-> System.out.println("有一个完成了,我继续"));
        
        future1.runAfterBoth(future,()-> System.out.println("都完成了,我继续"));
        
        future1.thenComposeAsync(x->CompletableFuture.supplyAsync(()->x+1))
                .thenComposeAsync(x->CompletableFuture.supplyAsync(()->x+2))
                .thenCompose(x->CompletableFuture.runAsync(()-> System.out.println("流操作结果:"+x)));
        TimeUnit.SECONDS.sleep(5);//主线程sleep,等待其他线程执行
    }
}

以上就是一文搞懂Java创建线程的五种方法的详细内容，更多关于Java创建线程的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

--结束END--

本文标题: 一文搞懂Java创建线程的五种方法

本文链接: https://lsjlt.com/news/151412.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 一文搞懂Java创建线程的五种方法
    目录题目描述解题思路代码详解第一种 继承Thread类创建线程第二种：实现Runnable接口创建线程第三种：实现Callable接口，通过FutureTask包装器来创建Threa...
    99+
    2024-04-02
  • 一文带你搞懂Java中线程的创建方式
    目录一. 继承Thread二. 创建Runnable对象三. 创建Callable对象四. 基于Runnable创建FutureTask总结一. 继承Thread 可以通过创建Thr...
    99+
    2023-03-06
    Java线程创建方式 Java线程创建 Java线程
  • 一文搞懂Java桥接方法
    目录1.桥接方法简介2. 什么时候会生成桥接方法3. 为什么生成泛型方法4. 根据桥接方法获取实际泛型方法 1.桥接方法简介 桥接方法是jdk1.5引入泛型后，为使java...
    99+
    2024-04-02
  • 一文彻底搞懂java多线程和线程池
    目录 什么是线程 一. Java实现线程的三种方式1.1、继承Thread类1.2、实现Runnable接口，并覆写run方法二. Callable接口...
    99+
    2024-04-02
  • 详解Java创建线程的五种常见方式
    目录Java中如何创建线程呢？1.显示继承Thread，重写run来指定现成的执行代码。2.匿名内部类继承Thread，重写run来执行线程执行的代码。3.显示实现Runnable接...
    99+
    2024-04-02
  • 一文搞懂Java中的线程安全与线程同步
    目录1.为什么需要线程同步线程安全问题2.怎么实现线程同步2.1.使用volatile关键字2.2.使用synchronized关键字1.为什么需要线程同步 什么是线程安全：指在被多...
    99+
    2024-04-02
  • java创建线程的两种方法区别
    在Java中创建一个线程有两种方法：继承Thread类和实现Runnable接口。下面通过两个例子来分析两者的区别：1）继承Thread类public class TestThread extends Thread { int count...
    99+
    2023-05-31
    java 创建线程 ava
  • Java线程的三种创建方式
    目录1、Thread2、Runnable和Thread3、Runnable和Thread4、三者对比5、注意项1、Thread 继承Thread类，并重写run方法 class ...
    99+
    2024-04-02
  • 一文搞懂Python中的进程,线程和协程
    目录1.什么是并发编程2.进程与多进程3.线程与多线程4.协程与多协程5.总结1.什么是并发编程 并发编程是实现多任务协同处理，改善系统性能的方式。Python中实现并发编程主要依靠...
    99+
    2024-04-02
  • 创建Java线程安全类的七种方法
    目录前言无状态没有共享状态消息传递不可变状态使用来自 java.util.concurrent 的数据结构同步块易失性领域总结前言 几乎每个 Java 应用程序都使用线程。像 Tom...
    99+
    2024-04-02
  • Java线程的创建方法
    这篇文章主要讲解了“Java线程的创建方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java线程的创建方法”吧！多线程指的是一个程序运行时，会包含多个线程同时进行。Java创建线程有三种...
    99+
    2023-06-02
  • java创建线程池一共有七种方式
    java创建线程池一共有七种方式 这 7 种实现方法分别是： Executors.newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。 Exe...
    99+
    2023-09-13
    java 开发语言
  • 一文带你你搞懂Java的3种IO模型
    目录Java BIOJava NIOJava AIO小结在Java中，一共有三种IO模型，分别是阻塞IO(BIO)、非阻塞IO(NIO)和异步IO(AIO)。 Java BIO J...
    99+
    2023-05-19
    Java 3种IO模型 Java IO模型 Java IO
  • 一文搞懂Go语言中文件的读写与创建
    目录1. 文件的打开与关闭1.1 os.open1.2 os.OpenFile() 指定模式打开文件2. 文件的读取2.1 打开文件的方式读取文件中的数据2.2 使用 bufio 整...
    99+
    2024-04-02
  • 一篇文章帮你搞懂什么是java的进程和线程
    目录为什么会有进程进程的概念进程的特征线程线程的结构进程之中创建线程的优点进程和线程的区别进程和线程之间的关系总结为什么会有进程 在简单的批处理操作系统中，作业时串行执行的，即一个作...
    99+
    2024-04-02
  • java创建多线程的七种方式
    一、继承Thread，重写run方法 通过自定义一个类（这里起名为：MyThread），继承Thread类，重写run方法，最后在main方法中new出MyThread实例，调用这个实例的继承的Thread类的start方法创建一个线程。 ...
    99+
    2023-09-26
    java
  • Java 中创建线程的几种方式
    Java 是一种面向对象的编程语言，它支持多线程编程。多线程编程是指在一个程序中同时运行多个线程，这些线程可以并行执行，以提高程序的效率和性能。Java 提供了多种创建线程的方法，本文将介绍这些方法以...
    99+
    2023-09-13
    java jvm servlet
  • 一篇文章带你搞懂Java线程池实现原理
    目录1. 为什么要使用线程池2. 线程池的使用3. 线程池核心参数4. 线程池工作原理5. 线程池源码剖析5.1 线程池的属性5.2 线程池状态5.3 execute源码5.4 wo...
    99+
    2022-11-13
    Java线程池实现原理 Java线程池原理 Java线程池实现 Java线程池
  • 一文搞懂四种Wrapper方法快速重构你的代码
    Wrapper方法是一种快速重构代码的方法，它可以在不改变原有代码逻辑的情况下，对其进行封装和扩展。以下是四种常见的Wrapper方...
    99+
    2023-09-21
    Wrapper
  • 一文带你搞懂useCallback的使用方法
    目录一、useCallback的作用二、useRef解决方案三、useReducer解决方案四、usePersistFn解决方案总结一、useCallback的作用 usecallb...
    99+
    2023-02-07
    react usecallback usecallback用法 手动实现useCallback
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作