JAVA多线程实现多线程的3种方式

三种分别是继承Thread、实现Runnable、实现Callable
最后一种是有返回值的
通常不建议显示创建线程，而是通过线程池来创建线程
这里只当学习用了

package com.test;
        import lombok.extern.slf4j.Slf4j;
        import java.util.concurrent.Callable;
        import java.util.concurrent.FutureTask;
/**
 * 线程测试
 * @author 黄蜂怪
 * @url //www.greatytc.com/u/842ce47b2d51
 */
@Slf4j
public class ThreadTest  {
    public static void main(String[] args) throws Exception {
        ThreadTest threadTest = new ThreadTest();
        threadTest.implementsRunnable();
        threadTest.extendsThread();
        FutureTask<String> task = threadTest.implementsCallable();
        log.info("主线程等待5秒，让异步线程有时间执行");
        Thread.sleep(5);
        while (true){
            if(task.isDone()){
                log.info("implementsCallable 返回：{}",task.get());
                break;
            }
            sleep(3);
            log.info("继续循环等待返回结果");
        }
    }
    /**
     * 通过实现Runnable接口实现
     */
    public void implementsRunnable() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                log.info("我是通过实现接口Runnable实现多线程，我图个简单，没写类，使用了匿内部类");
                ThreadTest.sleep(2);
            }
        };
        new Thread(runnable,"implementsRunnable线程").start();
    }
    /**
     * 通过继承Thread实现
     */
    public void extendsThread() {
        new MyThread("extendsThread线程").start();
    }
    /**
     * 通过实现接口Callable实现
     */
    public FutureTask<String> implementsCallable() {
        FutureTask<String> task = new FutureTask<>(new MyCall());
        new Thread(task,"implementsCallable线程").start();
        return task;
    }
    class MyThread extends Thread {
        public MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            log.info("我是通过继承Thread实现多线程，我图个简单，没写类，使用了内部类");
            ThreadTest.sleep(1);
        }
    }
    class MyCall implements Callable<String>{
        @Override
        public String call() {
            log.info("我是通过实现接口Callable实现多线程，我是有返回值的");
            sleep(10);
            return "异步执行完成";
        }
    }
    private static void sleep(long second){
        try {
            log.info("累了，歇{}秒",second);
            Thread.sleep(second*1000);
        }catch (InterruptedException e){
            log.error("线程中断异常,second:{}",second,e);
        }
    }
}

输出

2022-03-18 13:09:59.994 [implementsCallable线程] INFO  com.test.ThreadTest - 我是通过实现接口Callable实现多线程，我是有返回值的
2022-03-18 13:09:59.994 [implementsRunnable线程] INFO  com.test.ThreadTest - 我是通过实现接口Runnable实现多线程，我图个简单，没写类，使用了匿内部类
2022-03-18 13:09:59.994 [main] INFO  com.test.ThreadTest - 主线程等待5秒，让异步线程有时间执行
2022-03-18 13:09:59.994 [extendsThread线程] INFO  com.test.ThreadTest - 我是通过继承Thread实现多线程，我图个简单，没写类，使用了内部类
2022-03-18 13:09:59.997 [extendsThread线程] INFO  com.test.ThreadTest - 累了，歇1秒
2022-03-18 13:09:59.997 [implementsRunnable线程] INFO  com.test.ThreadTest - 累了，歇2秒
2022-03-18 13:09:59.997 [implementsCallable线程] INFO  com.test.ThreadTest - 累了，歇10秒
2022-03-18 13:10:00.003 [main] INFO  com.test.ThreadTest - 累了，歇3秒
2022-03-18 13:10:03.007 [main] INFO  com.test.ThreadTest - 继续循环等待返回结果
2022-03-18 13:10:03.007 [main] INFO  com.test.ThreadTest - 累了，歇3秒
2022-03-18 13:10:06.012 [main] INFO  com.test.ThreadTest - 继续循环等待返回结果
2022-03-18 13:10:06.012 [main] INFO  com.test.ThreadTest - 累了，歇3秒
2022-03-18 13:10:09.019 [main] INFO  com.test.ThreadTest - 继续循环等待返回结果
2022-03-18 13:10:09.019 [main] INFO  com.test.ThreadTest - 累了，歇3秒
2022-03-18 13:10:12.020 [main] INFO  com.test.ThreadTest - 继续循环等待返回结果
2022-03-18 13:10:12.021 [main] INFO  com.test.ThreadTest - implementsCallable 返回：异步执行完成