我正在参加「启航方案」

❤️作者主页：小虚竹

❤️作者简介：大家好,我是小虚竹。Java范畴优质创作者，CSDN博客专家，华为云享专家，年度人气作者，阿里云专家博主

❤️技术活，该赏

❤️点赞 收藏 ⭐再看，养成习气

PC端主页可联系我，欢迎问题咨询和技术交流！

零、前语

我的学习战略很简单，题海战略+ 费曼学习法。假如能把这100题都仔仔细细自己完结一遍，那意味着 JAVA语言 现已筑基成功了。后面的进阶学习，能够持续跟着我，一同走向架构师之路。

一、标题描述

标题：

Java创立线程的几种办法：

Java运用Thread类代表线程，一切线程目标都必须是Thread类或许其子类的实例。Java能够用以下5种办法来创立线程：

1）承继Thread类创立线程；

2）完结Runnable接口创立线程；

3）完结Callable接口，经过FutureTask包装器来创立Thread线程；

4）运用ExecutorService、Callable(或许Runnable)、Future完结由回来成果的线程。

5）运用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接口：

//创立固定数目线程的线程池。
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 com.xiaoxuzhu;
import java.util.concurrent.CountDownLatch;
/**
 * Description:承继Thread类创立线程
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修正记载:
 * 修正后版别	        修正人		修正日期			修正内容
 * 2022/5/15.1	    xiaoxuzhu		2022/5/15		    Create
 * </pre>
 * @date 2022/5/15
 */
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 com.xiaoxuzhu;
import java.util.concurrent.CountDownLatch;
/**
 * Description: 完结Runnable接口创立线程
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修正记载:
 * 修正后版别	        修正人		修正日期			修正内容
 * 2022/5/15.1	    xiaoxuzhu		2022/5/15		    Create
 * </pre>
 * @date 2022/5/15
 */
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 com.xiaoxuzhu;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * Description: 完结Callable接口，经过FutureTask包装器来创立Thread线程
 *  跟Runnable比，不同点在于它是一个具有回来值的，且会抛出反常
 *  //用futureTask接纳成果
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修正记载:
 * 修正后版别	        修正人		修正日期			修正内容
 * 2022/5/15.1	    xiaoxuzhu		2022/5/15		    Create
 * </pre>
 * @date 2022/5/15
 */
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 com.xiaoxuzhu;
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
 *
 * <pre>
 * 修正记载:
 * 修正后版别	        修正人		修正日期			修正内容
 * 2022/5/15.1	    xiaoxuzhu		2022/5/15		    Create
 * </pre>
 * @date 2022/5/15
 */
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();
        }
    }
}

第五种：运用CompletableFuture类创立异步线程，且是据有回来成果的线程

package com.xiaoxuzhu;
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
 *
 * <pre>
 * 修正记载:
 * 修正后版别	        修正人		修正日期			修正内容
 * 2022/5/15.1	    xiaoxuzhu		2022/5/15		    Create
 * </pre>
 * @date 2022/5/15
 */
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,等候其他线程履行
    }
}

多学一个知识点