创建线程的几种方式

一：继承Thread类

/**
 * 创建线程的方式-继承Thread类实现run方法（无返回值）
 * 好处：在run方法内部，可以直接通过this获取到当前线程，无需使用Thread.currentThread()方法
 * 缺点：该类不能再继承其他类
 * 2.任务与代码没有分离，当多个线程执行一样的任务时，需要多份代码
 * @Author: jun
 * @Date: 2022/7/17 17:27
 */
public class ThreadTest extends Thread{

    /**
     * 实现run方法
     * run方法一旦执行完毕，线程处于终止状态
     */
    @Override
    public void run() {
        System.out.println("子线程："+Thread.currentThread().getName());
        // 继承方式的好处就是可以通过this直接获取线程
        System.out.println("子线程this方式获取："+this.getName());
    }

    public static void main(String[] args) {
        // 创建一个ThreadTest实例，此时线程还没有启动，调用start方法开启线程
        ThreadTest threadTest = new ThreadTest();
        /*
        调用start()方法后，并没有马上去执行，而是处于就绪状态（指该线程已经获取了除CUP外的其他资源，等待获取CUP资源后处于运行状态）
         */
        threadTest.start();
        System.out.println("main线程："+Thread.currentThread().getName());
    }
}

二：实现Runnable接口

/**
 * 创建线程的方式-实现Runnable接口（无返回值）推荐使用
 * 好处：该类可以继承其他类
 * 2.当多线程执行相同任务时，只需要创建多个线程对象即可
 * @Author: jun
 * @Date: 2022/7/17 17:40
 */
public class RunnableTest implements Runnable{

    /**
     * 实现run方法
     * run方法一旦执行完毕，线程处于终止状态
     */
    @Override
    public void run() {
        System.out.println("子线程："+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        // 创建一个实现了Runnable接口的实现类
        RunnableTest runnableTest = new RunnableTest();
        // 创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(runnableTest);
        // 开启线程，调用start()方法后，并没有马上去执行，而是处于就绪状态（指该线程已经获取了除CUP外的其他资源，等待获取CUP资源后处于运行状态）
        thread.start();

        Thread thread1 = new Thread(runnableTest);
        thread1.start();
        System.out.println("main线程："+Thread.currentThread().getName());
    }
}

三：Callable和Future创建线程

package org.binfa.concurrentprogramming.basics;

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

/**
 * 创建线程的方式-实现callable接口（有返回值）
 * 缺点：返回值会阻塞主线程
 * @Author: jun
 * @Date: 2022/7/17 20:09
*/
public class CallerTaskTest implements Callable<String> {

    /**
     * 实现call方法
     * call 方法一旦执行完毕，线程处于终止状态
     */
    @Override
    public String call() throws Exception {
        System.out.println("子线程："+Thread.currentThread().getName());
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) {
        // 创建异步任务
        FutureTask<String> futureTask = new FutureTask<>(new CallerTaskTest());
        // 创建一个线程对象
        Thread thread = new Thread(futureTask);
        // 开启线程，调用start()方法后，并没有马上去执行，而是处于就绪状态（指该线程已经获取了除CUP外的其他资源，等待获取CUP资源后处于运行状态）
        thread.start();

        // 等待任务结束
        try {
            String s = futureTask.get();
            System.out.println("futureTask result="+s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("main线程："+Thread.currentThread().getName());
    }
}