1、java里启动线程的五种方式

1、继承 Thread 类：使用 new MyThread().start() 创建并启动一个 MyThread 的实例，会执行其中的 run() 方法。

2、实现 Runnable 接口：使用 new Thread(new MyRun()).start() 创建并启动一个线程，传入一个 MyRun 的实例，会执行其中的 run() 方法。

3、使用 Lambda 表达式：使用 lambda 表达式创建一个线程，然后启动线程。

4、使用 FutureTask 创建一个任务，并将 MyCall 的实例作为参数传入，然后创建一个线程执行这个任务，启动线程后获取任务的结果并打印出来。

5、使用线程池：创建一个线程池 ExecutorService，使用 Executors.newCachedThreadPool() 创建一个具有缓存的线程池。使用 execute() 方法提交一个任务，任务中输出 "Hello ThreadPool"。

2、代码测试

2.1、前期工具类准备

2.1.1 定义一个静态内部类 MyThread 继承自 Thread 类，重写了 run() 方法，并在其中输出 "Hello MyThread!"。为了实现方法1。

static class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("Hello MyThread!");
    }
}

2.2.2 定义一个静态内部类 MyRun 实现 Runnable 接口，重写了 run() 方法，并在其中输出 "Hello MyRun!"。

static class MyRun implements Runnable{
    @Override
    public void run() {
        System.out.println("Hello MyRun!");
    }
}

2.2.3 定义一个静态内部类 MyCall 实现 Callable<String> 接口，重写了 call() 方法，并在其中输出 "Hello MyCall"，然后返回字符串 "success"。

static class MyCall implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("Hello MyCall");
        return "success";
    }
}

2.2、main函数里的代码

new MyThread().start();
new Thread(new MyRun()).start();
new Thread(() -> {
    System.out.println("Hello Lambda!");
}).start();

FutureTask<String> task = new FutureTask<>(new MyCall());
Thread t = new Thread(task);
t.start();
System.out.println(task.get());

ExecutorService service = Executors.newCachedThreadPool();
service.execute(()->{
    System.out.println("Hello ThreadPool");
});

Future<String> f = service.submit(new MyCall());
String s = f.get();
System.out.println(s);
service.shutdown();

2.3、总体代码

public class Test {

    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("Hello MyThread!");
        }
    }

    static class MyRun implements Runnable{

        @Override
        public void run() {
            System.out.println("Hello MyRun!");
        }
    }

    static class MyCall implements Callable<String>{

        @Override
        public String call() throws Exception {
            System.out.println("Hello MyCall");
            return "success";
        }
    }

    public static void main(String[] args) throws Exception{
//        Solution solution = new Solution();
        new MyThread().start();
        new Thread(new MyRun()).start();
        new Thread(() -> {
            System.out.println("Hello Lambda!");
        }).start();

        FutureTask<String> task = new FutureTask<>(new MyCall());
        Thread t = new Thread(task);
        t.start();
        System.out.println(task.get());

        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(()->{
            System.out.println("Hello ThreadPool");
        });

        Future<String> f = service.submit(new MyCall());
        String s = f.get();
        System.out.println(s);
        service.shutdown();
    }
}