一、继承Thread，重写run方法

1. 创建出MyThread实例，并不代表在系统真的创建一个线程，只有调用start方法时，才创建出一个新的线程
2. 运行一次Java程序就启动了一个进程，一个进程里至少会有一个线程，这里JVM默认创建的线程就是main线程（主线程），main主线程和MyThread创建出来的新线程是同时执行，各执行各的；
3. 调用run方法会顺序执行

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            System.out.println("Hello World!!"+i);
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();//启动线程
        for(int i = 0;i <= 1000;i++){
            System.out.println("主线程的 Hello World!!"+i);
        }
        
    }
}

二、实现Runnable接口，重写run方法

• 通过自定义一个类 MyThread1 实现 Runnable 接口，重写 run 方法，最后在main方法new出MyThread1 实例 和 Thread实例，最后通过 start 方法创建并启动线程。
• 主线程和新线程是同时执行，互不影响

public class MyThread1 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 2000;i++){
            System.out.println( "我在玩手机"+i);
        }
    }
    public static void main(String[] args) {

        MyThread1 myThread1 = new MyThread1();
        new Thread(myThread1).start();

        for(int i = 0;i <= 2000;i++){
            System.out.println("我在吃饭"+i);
        }
    }
}

三、使用匿名内部类创建 Thread 子类对象

直接创建Thread子类，同时实例化出一个对象，重写run方法，最后通过start方法创建并启动线程

public class A {
    public static void main(String[] args) {

        Thread thread = new Thread(){
            @Override
            public void run(){
                System.out.println("使用匿名内部类创建 Thread 子类对象");
            }
        };
        thread.start();
    }
}

四、使用匿名内部类，实现Runnable接口

通过使用使用匿名内部类，实现Runnable接口作为Thread构造方法的参数，最后通过start创建并启动线程；

public class A {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
                public void run(){
                    System.out.println("使用匿名内部类创建 Thread 子类对象");
            }
        });
        thread.start();
    }
}

五、实现Callable接口

• 创建一个类 MyCallable 实现Callable接口
• 重写call方法（有返回值，表示多线程运行的结果）
• 创建MyCallable对象（表示多线程要执行的任务）
• 创建FutureTask的对象（管理多线程运行的结果）
• 创建Thread类的对象，并启动

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("实现Callable接口");
        return 2;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
       MyCallable myCallable = new MyCallable();
       FutureTask<Integer> f = new FutureTask<>(myCallable);
       Thread thread = new Thread(f);
       thread.start();
       System.out.println(f.get());
    }
}

六、使用线程池创建线程

在Java中，线程池的本体叫ThreadPoolExecutor，他的构造方法写起来十分麻烦，为了简化构造方法，标准库就提供了一系列方法，简化使用

public class MyThread4 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我正在学习" + i);
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();//创建一个没有上线的线程池

        // ExecutorService executorService1 = Executors.newFixedThreadPool(6);//创建固定数量的线程池

        executorService.submit(new MyThread4());//提交任务
        executorService.shutdown();//销毁线程池
    }
}