java 怎么开启多线程

Java中,实现多线程的方式主要有继承Thread类、实现Runnable接口、实现Callable接口以及使用线程池等，以下是对这些方式的详细介绍：

继承Thread类

• 原理：Thread类是Java中代表线程的类，通过继承该类并重写其run()方法，可以在run()方法中定义线程要执行的任务，然后创建该类的实例，并调用start()方法启动线程，此时JVM会自动调用run()方法执行线程任务。
• 示例代码：

  class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("我是通过继承Thread类创建的多线程，我叫" + Thread.currentThread().getName());
    }
  }

public class TestMyThread {
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
myThread1.setName(“Thread 1”);
MyThread myThread2 = new MyThread();
myThread2.setName(“Thread 2”);
MyThread myThread3 = new MyThread();
myThread3.setName(“Thread 3”);

    myThread1.start();
    myThread2.start();
    myThread3.start();
}

优点：简单直接，易于理解和使用，无需额外的接口实现或对象创建。
缺点：由于Java不支持多继承，如果类已经继承了其他类，就不能再继承Thread类，限制了类的扩展性。
 2. 实现Runnable接口
原理：Runnable接口是一个函数式接口，只有一个run()方法，实现该接口并重写run()方法，将线程任务定义在run()方法中，然后创建实现了Runnable接口的类的实例，并将其作为参数传递给Thread类的构造函数，创建Thread对象，最后调用start()方法启动线程。
示例代码：
```java
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我是通过实现Runnable接口创建的多线程，我叫" + Thread.currentThread().getName());
    }
}
public class TestMyRunnable {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

• 优点：避免了单继承的限制，一个类可以实现多个接口，更加灵活，有利于代码的解耦和复用。
• 缺点：需要额外创建Thread对象来启动线程，相比继承Thread类稍微复杂一些。

实现Callable接口

• 原理：Callable接口与Runnable接口类似，但Callable接口的call()方法可以返回一个结果，并且可以抛出异常，实现Callable接口后，需要将其实现类的实例包装在一个FutureTask对象中，FutureTask实现了RunnableFuture接口，而RunnableFuture接口继承了Runnable和Future接口，然后将FutureTask对象作为参数传递给Thread类的构造函数，创建Thread对象并启动线程，可以通过FutureTask的get()方法获取call()方法的返回结果。
• 示例代码：

  class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int a = 6;
        int b = 9;
        System.out.println("我是通过实现Callable接口创建的多线程，我叫" + Thread.currentThread().getName());
        return a + b;
    }
  }

public class TestMyCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable myCallable = new MyCallable();
FutureTask futureTask = new FutureTask<>(myCallable);
Thread thread = new Thread(futureTask);
thread.start();
System.out.println(“返回值为：” + futureTask.get());
}
}

优点：可以获取线程执行的结果，适用于需要返回计算结果的场景。
缺点：代码相对复杂，需要处理FutureTask对象的创建和使用，以及可能的异常处理。
 4. 使用线程池（ExecutorService）
原理：Java通过Executors提供了多种创建线程池的方法，如newCachedThreadPool()、newFixedThreadPool()、newScheduledThreadPool()和newSingleThreadExecutor()等，线程池可以管理线程的生命周期，提高线程的复用性，减少线程创建和销毁的开销，ExecutorService接口中的execute()和submit()方法都可以用来提交任务到线程池，execute()方法适用于不需要返回值且不需要处理异常的场景，它只能提交Runnable任务；submit()方法适用于需要返回值或需要处理异常的场景，它可以提交Runnable或Callable任务，并返回一个Future对象，通过Future对象可以获取任务的执行结果或状态。
示例代码：
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我是通过线程池执行的多线程，我叫" + Thread.currentThread().getName());
    }
}
public class TestThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyRunnable());
        }
        executorService.shutdown();
    }
}

• 优点：可以有效管理和复用线程，提高系统的性能和资源利用率，避免频繁创建和销毁线程带来的开销，同时可以方便地控制线程的数量和并发度。
• 缺点：使用相对复杂，需要根据具体的业务场景选择合适的线程池类型和参数配置。

对比表格

相关FAQs

• 问题1：继承Thread类和实现Runnable接口有什么区别？
• 回答：继承Thread类是直接继承Thread类并重写run()方法来定义线程任务，创建实例后调用start()启动线程，简单直接但受单继承限制；实现Runnable接口是实现该接口并重写run()方法，将实例作为参数传给Thread构造函数创建线程并启动，避免了单继承限制，更加灵活，但需额外创建Thread对象。
• 问题2：什么时候应该使用Callable接口而不是Runnable接口？
• 回答：如果线程任务需要返回一个结果，比如进行一些计算并返回计算结果，就应该使用Callable接口，因为Callable接口的call()方法可以返回值，而Runnable接口的run()方法不能返回结果，例如在需要进行异步计算并获取计算结果的场景中，使用Callable接口更为合适。