class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"::通过继承Thread方式创建线程");
    }
}
public class CreateThread {
    public static void main(String[] args) {
        Thread t =new MyThread01();
        t.setName("t1");
        t.start();
        //结果：t1::通过继承Thread方式创建线程
    }
}

2.过程说明

（1）、定义子类继承Thread类

（2）、子类中重写Thread类中的run方法

（3）、创建该子类对象，即创建了线程对象

（4）、调用线程对象的start方法，启动线程

三、实现Runnable接口方式

1、代码实现

class MyThread02 implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName()+"::通过实现Runnable方式创建线程");
    }
}

public class CreateThread {
    public static void main(String[] args) {
        MyThread02 t1 = new MyThread02();
        Thread t =new Thread(t1);
        t.setName("t2");
        t.start();
        //结果：t2::通过实现Runnable方式创建线程

    }
}

2、过程说明

（1）、定义子类，实现Runnable接口

（2）、子类重写Runable接口中的run方法

（3）、通过Thread类的含参数构造器创建线程对象

（4）、将子类的对象作为实际参数传给Thread类的构造器中

（5）、调用Thread类的start方法，开启线程（start方法会调用子类的run方法）

四、实现Callable方式 ,创建带返回值的线程

1、代码实现

public class NumThread implements Callable {
    
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 10 ; i++) {
            if(i%2==0){
                System.out.print(i+"  ");
                sum+=i;
            }
        }

        return sum;
    }
}
public class ThreadNew  {

    public static void main(String[] args) {
        NumThread n = new NumThread();

        FutureTask futureTask = new FutureTask (n);
        new Thread(futureTask).start(); 
        try {

            Object o = futureTask.get();
            System.out.println("计算总和:"+o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } 
    }
//结果：0  2  4  6  8  10  计算总和:30
}

2、过程说明

（1）、定义子类，实现Callable接口

（2）、子类重写Callable接口中的call方法

（3）、通过FutureTask 的有参构造函数创建FutureTask 对象

（4）、将子类的对象作为实际参数传给FutureTask 类的构造器中

（5）、通过Thread类的含参数构造器创建线程对象

（4）、将FutureTask 类的对象作为实际参数传给Thread类的构造器中

（5）、调用Thread类的start方法，开启线程

（6）、线程创建后，调用FutureTask 的get方法获取返回值

五、线程池方式创建线程

1、代码实现

 public static void main(String[] args) {
        // 创建一个固定数量的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int idx = i;

            executor.execute(new Runnable() { // 创建线程并添加到线程池中, 并启动运行线程
                @Override
                public void run() {
                    System.out.println("当前线程名称:" + Thread.currentThread().getName() + ", 参数idx = " + idx);
                }
            });
        }
        executor.shutdown(); // 关闭线程池
    }
    /*结果：  
    当前线程名称:pool-1-thread-1, 参数idx = 0
    当前线程名称:pool-1-thread-5, 参数idx = 4
    当前线程名称:pool-1-thread-4, 参数idx = 3
    当前线程名称:pool-1-thread-3, 参数idx = 2
    当前线程名称:pool-1-thread-2, 参数idx = 1
    当前线程名称:pool-1-thread-3, 参数idx = 8
    当前线程名称:pool-1-thread-4, 参数idx = 7
    当前线程名称:pool-1-thread-5, 参数idx = 6
    当前线程名称:pool-1-thread-1, 参数idx = 5
    当前线程名称:pool-1-thread-2, 参数idx = 9
    */

2、说明

（1）、通过Executors类中的不同静态方法，创建不同类型的线程池

        Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
        Executors.newFixedThreadPool(n);创建一个可重用固定线程数的线程池
        Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
        Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

（2）、调用ExecutorService接口中的execute方法执行线程

void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
<T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable

总结

一、继承Thread与实现Runnable接口说明

Thread类其实就是实现了Runnable接口：public class Thread implements Runnable

区别：
        继承Thread：线程代码存放Thread子类run方法中。
        实现Runnable：线程代码存在接口的子类的run方法。
实现方式的好处：
        避免了单继承的局限性
        多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。