Java中有哪几种方式来创建线程执行任务？

Java中有哪几种方式来创建线程执行任务？

1.继承Thread类

继承Thread类，重写run()方法，创建一个Thread对象并调用其start()方法启动线程。

public class Thread1 extends Thread{
          
   
    @Override
    public void run() {
          
   
        for (int i = 0; i < 20; i++) {
          
   
            System.out.println("测试打印线程"+i);
        }
    }

    public static void main(String[] args) {
          
   
        Thread1 thread1 = new Thread1();
        thread1.start();
        for (int i = 0; i < 20; i++) {
          
   
            System.out.println("我是主线程"+i);
        }
    }
}

但是要注意一下run和start的区别:

在Java中，Thread.start() 和 Thread.run() 方法也可以用来启动一个新线程。

在Java中，调用 Thread.start() 方法会创建一个新线程并使其执行该线程的 run() 方法中的代码。而 Thread.run() 方法只是在当前线程中直接调用 run() 方法的代码。这就意味着如果你调用 run() 方法，那么它实际上就是在当前线程中执行，而不是在新线程中运行。

因此，如果你想要创建一个新线程来并发地执行任务，你应该使用 Thread.start() 方法。它将会使得新线程在后台执行，以便让程序并行地执行多个任务。而如果你只是想在当前线程中执行一些简单的操作，你可以直接调用 Thread.run() 方法。

总结一下，Java中的Thread.start()和Thread.run()方法的区别如下：

Thread.start() 方法会创建一个新的线程，并在该线程中执行 run() 方法中的代码。 Thread.run() 方法是在当前线程中直接调用 run() 方法的代码。

2.实现Runnable接口

public class Thread2 {
          
   
    public static void main(String[] args) {
          
   
        Thread t = new Thread(() -> System.out.println("hello"));
        t.start();
    }
}

3.实现Callable接口

public class Thread3 implements Callable<Boolean> {
          
   
    @Override
    public Boolean call() throws Exception {
          
   
        System.out.println("实现了callable");
        return true;
    }

    public static void main(String[] args) {
          
   
        Thread3 thread = new Thread3();
        FutureTask<Boolean> futureTask = new FutureTask<Boolean>(thread);
        Thread t = new Thread(futureTask);
        t.start();
    }
}

总结：实现Callable接口，实现call()方法，得使用Thread+FutureTask配合，这种方式支持拿到异步执行任务的结果

4.利用线程池来创建线程

public class Executor implements Runnable{
          
   

    public static void main(String[] args) {
          
   
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Executor());
    }
    
    @Override
    public void run() {
          
   
        System.out.println("使用线程池创建线程");
    }
}

实现Callable接口或者Runnable接口都可以，由ExecutorService来创建线程

public class Executor {
          
   
    public static void main(String[] args) throws InterruptedException {
          
   
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
          
   
            executor.submit(() -> {
          
   
                System.out.println("Thread-" + Thread.currentThread().getId() + " start");
                // do some work...

                System.out.println("Thread-" + Thread.currentThread().getId() + " end");
            });
        }
        executor.shutdown();
        // 等待所有任务完成
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        System.out.println("All tasks done.");
    }
}

Thread-12 start
Thread-15 start
Thread-15 end
Thread-14 start
Thread-13 start
Thread-14 end
Thread-12 end
Thread-16 start
Thread-16 end
Thread-13 end
All tasks done.

5.总结

以上几种方式，底层都是基于Runnable。所以创建线程的方式有4种也可以说是1种。