创建线程的四种方式

继承Thread类

通过继承Thread类，并重写它的run方法，我们就可以创建一个线程，然后通过start方法开启线程（开启线程前的代码会先执行完）。不要使用run方法，因为使用run方法会把线程当作普通方法使用，就不是多线程运行了

/**
 * @author LeDao
 * @company
 * @create 2021-07-09 22:45
 */
public class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("线程运行");
    }

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

实现 Runnable接口

通过实现Runnable，并实现run方法，也可以创建一个线程，这种方法比继承Thread类好

/**
 * @author LeDao
 * @company
 * @create 2021-07-09 22:45
 */
public class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println("运行线程");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread());
        thread.start();
    }
}

实现 Callable 接口

实现Callable接口，并结合Future实现

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

/**
 * @author LeDao
 * @company
 * @create 2021-07-09 22:45
 */
public class MyThread implements Callable {

    @Override
    public String call() {
        return "1";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task = new FutureTask(new MyThread());
        new Thread(task).start();
        String result = (String) task.get();
        System.out.println(result);
    }
}

通过线程池创建线程

用JDK自带的Executors来创建线程池对象（推荐使用）

package thread;

import cn.hutool.core.thread.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * @author LeDao
 * @company
 * @create 2022-04-25 13:44
 */
public class ThreadTest3 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("玩游戏---" + i);
        }
    }

    public static void main(String[] args) {
        //获取系统处理器个数，作为线程池数量
        int nThreads = Runtime.getRuntime().availableProcessors();
        System.out.println(nThreads);
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNamePrefix("demo-pool-%d").build();
        ExecutorService executorService = new ThreadPoolExecutor(nThreads,
                200,
                0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(1024),
                namedThreadFactory,
                new ThreadPoolExecutor.AbortPolicy());
        executorService.execute(new ThreadTest3());
        for (int i = 0; i < 1000; i++) {
            System.out.println("学习---" + i);
        }
        executorService.shutdown();
    }
}