1. 第一种

继承Thread，重写run方法

public class demo1 {
    public static void main(String[] args) {
        /**
         * 多线程的第一种启动方式
         * 1. 定义一个类继承Thread
         * 2. 重写run方法
         * 3. 创建子类的对象，并启动线程
         */
        MyThread myThread = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();
        myThread.setName("线程1");
        myThread2.setName("线程2");
        myThread3.setName("线程3");
        // start开启线程
        myThread.start();
        myThread2.start();
        myThread3.start();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "重写run方法...");
        }
    }
}

2. 第二种

实现Runnable接口的方式进行实现；
注意实现Runnable接口，就不能直接调用getName()，可以通过Thread.currentThread();获取当前执行的线程对象，再通过thread.getName()获取线程名，用于区分结果的输出；

public class demo2 {
    public static void main(String[] args) {
        /**
         * 多线程的第二种启动方式
         * 1. 定义一个类实现Runnable接口
         * 2. 重写run方法
         * 3. 创建类的对象
         * 4. 创建一个Thread类的对象，并启动线程
         */

        // 创建MyRun的对象
        // 表示多线程要执行的任务
        MyRun myRun = new MyRun();

        // 创建线程对象
        Thread thread = new Thread(myRun);
        Thread thread2 = new Thread(myRun);
        thread.setName("t1");
        thread2.setName("t2");

        thread.start();
        thread2.start();
    }
}
class MyRun implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 获取到当前线程的对象
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName() + "重写run方法...");
        }
    }
}

第三种

利用Callable接口和Future接口方式实现

public class demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 多线程的第三种实现方式：
         *      特点：可以获取到多线程运行的结果
         *      1. 创建一个类MyCallable实现Callable接口
         *      2. 重写call（有返回值，表示多线程运行的结果）
         *      3. 创建MyCallable的对象（表示多线程要执行的任务）
         *      4. 创建FutureTask的对象（作用管理多线程运行的结果）
         *      5. 创建Thread类的对象，并启动（表示线程）
         */
        // 创建MyCallable的对象（表示多线程要执行的任务）
        MyCallable myCallable = new MyCallable();
        // 创建FutureTask的对象（作用管理多线程运行的结果）
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(myCallable);
        // 创建Thread类的对象，并启动（表示线程）
        Thread thread = new Thread(integerFutureTask);
        // 启动线程
        thread.start();
        // 获取多线程结果
        Integer integer = integerFutureTask.get();
        System.out.println(integer);
    }
}
class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        // 求1~100之间的和
        int temp = 0;
        for (int i = 1; i <= 100; i++) {
            temp = temp + i;
        }
        return temp;
    }
}