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

目录
  • 题目描述
  • 解题思路
  • 代码详解
    • 第一种 继承Thread类创建线程
    • 第二种:实现Runnable接口创建线程
    • 第三种:实现Callable接口,通过FutureTask包装器来创建Thread线程
    • 第四种:使用ExecutorService、Callable(或者Runnable)、Future实现返回结果的线程
    • 第五种:使用ComletetableFuture类创建异步线程,且是据有返回结果的线程

题目描述

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;

/**
 * Description:继承Thread类创建线程
 *
 * @author 小王同学
 * @version 1.0
 */

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;

/**
 * Description: 实现Runnable接口创建线程
 *
 * @author 小王同学
 * @version 1.0
 */

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;

/**
 * Description: 实现Callable接口,通过FutureTask包装器来创建Thread线程
 *  跟Runnable比,不同点在于它是一个具有返回值的,且会抛出异常
 *  //用futureTask接收结果
 *
 * @author 小王同学
 * @version 1.0
 */

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;

/**
 * Description: 使用ExecutorService、Callable(或者Runnable)、Future实现由返回结果的线程
 *
 * @author xiaoxuzhu
 * @version 1.0
 */

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;

/**
 * Description:  使用CompletableFuture类创建异步线程,且是据有返回结果的线程。
 *
 * @author xiaoxuzhu
 * @version 1.0
 */

public class ThreadDemo5 {

    /**
     * A任务B任务完成后,才执行C任务
     * 返回值的处理
     * @param
     *@return void
     **/
    @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());

    }

    /**
     * 在Java8中,CompletableFuture提供了非常强大的Future的扩展功能,可以帮助我们简化异步编程的复杂性,
     * 并且提供了函数式编程的能力,可以通过回调的方式处理计算结果,也提供了转换和组合 CompletableFuture 的方法
     *
     *  注意: 方法中有Async一般表示另起一个线程,没有表示用当前线程
     */
    @Test
    public void test01() throws Exception {
        ExecutorService service = Executors.newFixedThreadPool(5);
        /**
         *  supplyAsync用于有返回值的任务,
         *  runAsync则用于没有返回值的任务
         *  Executor参数可以手动指定线程池,否则默认ForkJoinPool.commonPool()系统级公共线程池
         */
        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());
        /**
         * thenApply,一个线程依赖另一个线程可以使用,出现异常不执行
         */
        //第二个线程依赖第一个的结果
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5).thenApply(x -> x);

        /**
         * handle 是执行任务完成时对结果的处理,第一个出现异常继续执行
         */
        CompletableFuture<Integer> future2 = future1.handleAsync((x, y) -> x + 2);
        System.out.println(future2.get());//7
        /**
         * thenAccept 消费处理结果,不返回
         */
        future2.thenAccept(System.out::println);
        /**
         * thenRun  不关心任务的处理结果。只要上面的任务执行完成,就开始执行
         */
        future2.thenRunAsync(()-> System.out.println("继续下一个任务"));
        /**
         * thenCombine 会把 两个 CompletionStage 的任务都执行完成后,两个任务的结果交给 thenCombine 来处理
         */
        CompletableFuture<Integer> future3 = future1.thenCombine(future2, Integer::sum);
        System.out.println(future3.get()); // 5+7=12
        /**
         * thenAcceptBoth : 当两个CompletionStage都执行完成后,把结果一块交给thenAcceptBoth来进行消耗
         */
        future1.thenAcceptBothAsync(future2,(x,y)-> System.out.println(x+","+y)); //5,7
        /**
         * applyToEither
         * 两个CompletionStage,谁执行返回的结果快,我就用那个CompletionStage的结果进行下一步的转化操作
         */
        CompletableFuture<Integer> future4 = future1.applyToEither(future2, x -> x);
        System.out.println(future4.get()); //5
        /**
         * acceptEither
         * 两个CompletionStage,谁执行返回的结果快,我就用那个CompletionStage的结果进行下一步的消耗操作
         */
        future1.acceptEither(future2, System.out::println);
        /**
         * runAfterEither
         * 两个CompletionStage,任何一个完成了都会执行下一步的操作(Runnable
         */
        future1.runAfterEither(future,()-> System.out.println("有一个完成了,我继续"));
        /**
         * runAfterBoth
         * 两个CompletionStage,都完成了计算才会执行下一步的操作(Runnable)
         */
        future1.runAfterBoth(future,()-> System.out.println("都完成了,我继续"));
        /**
         * thenCompose 方法
         * thenCompose 方法允许你对多个 CompletionStage 进行流水线操作,第一个操作完成时,将其结果作为参数传递给第二个操作
         * thenApply是接受一个函数,thenCompose是接受一个future实例,更适合处理流操作
         */
        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创建线程的资料请关注我们其它相关文章!

(0)

相关推荐

  • 关于Java创建线程的2种方式以及对比

    目录 1. 继承Thread类 2. 实现Runnable接口: 创建线程的两种方式对比: 线程的完整生命周期: 总结 Java中两种创建线程的方式: 1. 继承Thread类 重写run()方法 new一个线程对象 调用对象的start()启动线程 class Handler extends Thread{ public void run(){ //重写run()方法 } public static void main(String[] args){ Thread thread=new Han

  • Java并发编程之线程创建介绍

    目录 1.线程与进程 2.线程的创建与运行 1.线程与进程 进程是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,线程则是一个实体,一个进程中至少有一个线程,是CPU调度和分配的基本单位,进程中的多个线程共享进程的资源. 进程的三个特征: 动态性 : 进程是运行中的程序,要动态的占用内存,CPU和网络等资源. 独立性 : 进程与进程之间是相互独立的,彼此有自己的独立内存区域. 并发性 : 假如CPU是单核,同一个时刻其实内存中只有一个进程在被执行.CPU会分时轮询切换依次为每

  • Java线程的三种创建方式

    目录 1.Thread 2.Runnable和Thread 3.Runnable和Thread 4.三者对比 5.注意项 1.Thread 继承Thread类,并重写run方法 class ThreadDemo1 extends Thread { @Override public void run() { log.info("{}", Thread.currentThread().getName()); } } 线程启动方式: ThreadDemo1 t1 = new ThreadDe

  • Java都有哪些创建线程的方法

    目录 1.继承Thread类 1.1 普通类继承Thread 1.2 匿名内部类 1.3 缺点分析 2.实现Runnable接口 2.1 普通类实现Runnable 2.2 匿名Runnable实现类 2.3 Lambda创建Runnable 2.4 缺点分析 3.使用Callable接口 3.1 普通类实现Callable 3.2 匿名Callable实现类 总结 在 Java 中,线程的创建方法有 7 种,分为以下 3 大类: 继承 Thread 类的方式,它有 2 种实现方法. 实现 Ru

  • 详解Java创建线程的五种常见方式

    目录 Java中如何创建线程呢? 1.显示继承Thread,重写run来指定现成的执行代码. 2.匿名内部类继承Thread,重写run来执行线程执行的代码. 3.显示实现Runnable接口,重写run方法. 4.匿名内部类实现Runnable接口,重写run方法 5.通过lambda表达式来描述线程执行的代码 [面试题]:Thread的run和start之间的区别? Thread类的具体用法 Thread类常见的一些属性 中断一个线程 1.方法一:让线程run完 2.方法二:调用interr

  • Java线程创建的四种方式总结

    多线程的创建,方式一:继承于Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run()--->将此线程执行的操作声明在run()中 3.创建Thread类的子类的对象 4.通过此对象调用start(): start()方法的两个作用: A.启动当前线程 B.调用当前线程的run() 创建过程中的两个问题: 问题一:我们不能通过直接调用run()的方式启动线程 问题二:在启动一个线程,遍历偶数,不可以让已经start()的线程去执行,会报异常:正确的方式是重新创建一

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

    目录 题目描述 解题思路 代码详解 第一种 继承Thread类创建线程 第二种:实现Runnable接口创建线程 第三种:实现Callable接口,通过FutureTask包装器来创建Thread线程 第四种:使用ExecutorService.Callable(或者Runnable).Future实现返回结果的线程 第五种:使用ComletetableFuture类创建异步线程,且是据有返回结果的线程 题目描述 Java创建线程的几种方式 Java使用Thread类代表线程,所有线程对象都必须

  • Java 创建线程的3种方法及各自的优点

    1. 继承 Thread 类,然后调用 start 方法. class MyThread extends Thread { //重写run方法,线程运行后,跑的就是run方法 public void run(){ //System.out.println(""); } public static void main(String[] args){ Thread t1 = new MyThread(); t1.start(); //线程运行,调用的 run()方法. } } 2. 实现

  • Java创建线程的五种写法总结

    目录 通过继承Thread类并实现run方法创建一个线程 通过实现Runnable接口,并实现run方法的方法创建一个线程 通过Thread匿名内部类创建一个线程 通过Runnable匿名内部类创建一个线程 通过Lambda表达式的方式创建一个线程 通过继承Thread类并实现run方法创建一个线程 // 定义一个Thread类,相当于一个线程的模板 class MyThread01 extends Thread { // 重写run方法// run方法描述的是线程要执行的具体任务@Overri

  • java创建线程的两种方法区别

    在Java中创建一个线程有两种方法:继承Thread类和实现Runnable接口. 下面通过两个例子来分析两者的区别: 1)继承Thread类 public class TestThread extends Thread { int count = 3; public TestThread(String ThreadName) { super(ThreadName); } @Override public void run() { for (int i = 0; i < 10; i++) if

  • 一文搞懂JAVA 修饰符

    Java语言提供了很多修饰符,主要分为以下两类: 访问修饰符 非访问修饰符 修饰符用来定义类.方法或者变量,通常放在语句的最前端.我们通过下面的例子来说明: public class ClassName { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] argum

  • 一文搞懂Java中对象池的实现

    目录 1. 什么是对象池 2. 为什么需要对象池 3. 对象池的实现 4. 开源的对象池工具 5. JedisPool 对象池实现分析 6. 对象池总结 最近在分析一个应用中的某个接口的耗时情况时,发现一个看起来极其普通的对象创建操作,竟然每次需要消耗 8ms 左右时间,分析后发现这个对象可以通过对象池模式进行优化,优化后此步耗时仅有 0.01ms,这篇文章介绍对象池相关知识. 1. 什么是对象池 池化并不是什么新鲜的技术,它更像一种软件设计模式,主要功能是缓存一组已经初始化的对象,以供随时可以

  • 一文搞懂Java并发AQS的共享锁模式

    目录 概述 自定义共享锁例子 核心原理机制 源码解析 成员变量 共享锁获取acquireShared(int) 共享释放releaseShared(int) 概述 这篇文章深入浅出理解Java并发AQS的独占锁模式讲解了AQS的独占锁实现原理,那么本篇文章在阐述AQS另外一个重要模式,共享锁模式,那什么是共享锁呢? 共享锁可以由多个线程同时获取, 比较典型的就是读锁,读操作并不会产生副作用,所以可以允许多个线程同时对数据进行读操作而不会有线程安全问题,jdk中的很多并发工具比如ReadWrite

  • 一文搞懂Java ScheduledExecutorService的使用

    目录 一.创建ScheduledExecutorService对象 二.ScheduledExecutorService方法 三.固定速率和固定延时的区别 1. 固定速率 2. 固定延时 四.调度多个任务 五.其他要点 JUC包(java.util.concurrent)中提供了对定时任务的支持,即ScheduledExecutorService接口. 本文对ScheduledExecutorService的介绍,将基于Timer类使用介绍进行,因此请先阅读Timer类使用介绍文章. 此处为语雀

  • 一文搞懂Java中的注解和反射

    目录 1.注解(Annotation) 1.1 什么是注解(Annotation) 1.2 内置注解 1.3 元注解(meta-annotation) 1.4 自定义注解 2.反射(Reflection) 2.1 反射和反射机制 2.2 Class类的获取方式和常用方法 2.3 反射的使用 1.注解(Annotation) 1.1 什么是注解(Annotation) 注解不是程序本身,可以在程序编译.类加载和运行时被读取,并执行相应的处理.注解的格式为"@注释名(参数值)",可以附加在

随机推荐