多线程创建方式

方式一：继承Thread

/**
 * 方法一：继承Thread类，作为线程对象存在（继承Thread对象）
 * */
public class Way01 extends Thread{

    public Way01(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (!interrupted()){
            MyTool.printTimeAndThread(getName() + "执行了...");
        }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            MyTool.printTimeAndThread(getName() + "睡眠中被打断...");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Way01 t1 = new Way01("t1");
        Way01 t2 = new Way01("t2");

        t1.start();
        t2.start();
        
        // t1.interrupt();
    }
}

方式二：实现Runnable接口

public class Way02 implements Runnable{
    @Override
    public void run() {
        while (true){
            MyTool.printTimeAndThread("被执行了...");
        }
    }
    public static void main(String[] args) {
        //将线程任务传给线程对象
        Thread thread = new Thread(new Way02(),"way02");
        //启动线程
        thread.start();
    }
}

方式三：Thread + 匿名内部类

public class Way03 {

    public static void main(String[] args) {
        // 创建无参线程对象
        new Thread("t1"){
            @Override
            public void run() {
                System.out.println("线程执行了...");
            }
        }.start();

        // 创建带线程任务的线程对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程执行了...");
            }
        },"t2").start();


        //创建带线程任务并且重写run方法的线程对象
        /*
         *  创建带线程任务Runnable并且重写Thread run方法的线程对象中，为什么只运行了Thread的run方法。看Thread类的源码的定义，
         *  public class Thread implements Runnable { }
         *  可以看到Thread实现了Runnable接口，而Runnable接口里有一个run方法。
         *  所以,最终调用的重写的方法应该是Thread类的run方法。而不是Runnable接口的run方法。
         * */
        new Thread(new Runnable() { //重写runnable里的run方法
            @Override
            public void run() {
                System.out.println("runnable run 线程执行了...");
            }
        },"t3"){  //重写Thread里的run方法
            @Override
            public void run() {
                System.out.println("override run 线程执行了...");
            }
        }.start();
    }
}

方式四：java8 Lambda 创建线程

/**
 * java Lambda 创建线程
 * */
public class Way07 {
    public static void main(String[] args) {
        Thread thread = new Thread(() ->{
            MyTool.printTimeAndThread("创建Runnable对象并重写run方法,数创建Thread对象！");
        },"t1");

        thread.start();
    }
}

方式五：Thread + FuturnTask + Callable(可获取返回值)

/**
 * 创建带返回值的线程
 *
 * Thread + FutureTask + Callable: 该方式可以通过阻塞回调获取异步任务返回值
 * 原理：
 *      （1）为什么FutureTask可以作为Thread构造函数的参数？
 *          三种对象对应关系：
 *          1.Callable是一个函数式接口，该接口有一个返回值泛型 V,是FutureTask的构造参数
 *          2.FutureTask是RunnableFuture的一个具体实现类，泛型为V
 *          3.RunnableFuture是Runnable和Future接口的实现类
 *          4.Thread的构造函数有：
 *              public Thread(Runnable target) {
 *                  init(null, target, "Thread-" + nextThreadNum(), 0);
 *              }
 *          5.所以在创建Thread对象时可以使用FutureTask对象作为构造器的参数
 *      （2）为什么FutureTask可以获取返回值？
 *          1.因为Future接口里有一个get()方法可以获取返回值
 *          2.FutureTask是RunnableFuture的一个具体实现类，泛型为V
 *          3.RunnableFuture是Runnable和Future接口的实现类
 *          4.所以FutureTask也具有可以获取返回值的功能，
 *
 * */
public class Way04 implements Callable {
    /**
     * 重写callable接口中的call()方法
     * */
    @Override
    public Object call() throws Exception {
        Integer integer = new Integer(1);
        MyTool.printTimeAndThread("其他业务处理...返回值为："+integer);
        return integer;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Way04 callable = new Way04();
        //创建带返回值的任务
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
        //将带有返回值的任务传递给线程
        Thread thread = new Thread(futureTask);

        thread.start();
        //获取任务的返回值
        Integer o = futureTask.get();

        MyTool.printTimeAndThread("获取到的结果为：" + o);
    }
}

方式六：Timer + 匿名内部类

/**
 * 定时器Timer
 * */
public class Way05 {

    public static void main(String[] args) {
        Timer timer = new Timer("Timer");
        /*
        * TimerTask 定时任务
        * delay 延迟多少秒启动
        * period 多久循环执行一次
        * */
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                MyTool.printTimeAndThread("线程启动执行了...");
            }
        },1000,1000);
    }
}

方式七： 线程池 + 任务

/**
 * 线程池创建线程
 * */
public class Way06 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(8);

        for (int i = 0; i < 8; i++) {
            //为线程池分配任务
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    MyTool.printTimeAndThread(Thread.currentThread().getName()+"执行了....");
                }
            });
        }
        //关闭线程池
        executorService.shutdown();
    }
}

打印工具类

public class MyTool {

    public static void sleepMillis(Long millis){
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void printTimeAndThread(String tag){
        String result =  new StringJoiner("\t|\t")
                .add(String.valueOf(Instant.now()))
                .add(String.valueOf(System.currentTimeMillis()))
                .add(String.valueOf(Thread.currentThread().getId()))
                .add(Thread.currentThread().getName())
                .add(tag)
                .toString();
        System.out.println(result);
    }

    public static void sleep(double i) {
        try {
            TimeUnit.MILLISECONDS.sleep((int) (i * 1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}