0
点赞
收藏
分享

微信扫一扫

Java多线程入门:创建线程的三种方式

在 Java 中,创建线程有三种主要方式:继承 Thread 类、实现 Runnable 接口和使用 CallableFuture。下面分别介绍这三种方式。

1. 继承 Thread

通过继承 Thread 类并重写其 run() 方法来创建线程。

步骤:

  1. 创建一个类继承 Thread 类。
  2. 重写 run() 方法,该方法是线程执行的主体。
  3. 创建该类的实例,并调用 start() 方法启动线程。

示例代码:

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动线程
    }
}

注意:

  • start() 方法会启动线程,并自动调用 run() 方法。
  • 不要直接调用 run() 方法,否则它只是普通的方法调用,不会启动新线程。

2. 实现 Runnable 接口

通过实现 Runnable 接口并实现其 run() 方法来创建线程。

步骤:

  1. 创建一个类实现 Runnable 接口。
  2. 实现 run() 方法,定义线程执行的任务。
  3. 创建 Thread 对象时,将实现了 Runnable 的对象作为参数传入。
  4. 调用 Thread 对象的 start() 方法启动线程。

示例代码:

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();  // 启动线程
    }
}

优点:

  • 使用 Runnable 接口可以避免单继承的限制(Java 中类只能继承一个父类)。
  • 更加灵活,适合资源共享的情况。

3. 使用 CallableFuture

Callable 接口与 Runnable 类似,但它可以返回结果并且可以抛出异常。Callable 需要与 FutureTaskExecutorService 配合使用。

步骤:

  1. 创建一个类实现 Callable 接口,并实现 call() 方法。
  2. call() 方法可以返回结果,并且可以抛出异常。
  3. 使用 FutureTask 包装 Callable 对象。
  4. FutureTask 对象传递给 Thread 并启动线程。
  5. 使用 FutureTaskget() 方法获取线程执行的结果。

示例代码:

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable is running: " + Thread.currentThread().getName());
        return 42;  // 返回结果
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();

        // 获取线程执行的结果
        Integer result = futureTask.get();
        System.out.println("Result from Callable: " + result);
    }
}

优点:

  • Callable 可以返回结果,而 Runnable 不能。
  • Callable 可以抛出异常,便于错误处理。

总结

方式 特点
继承 Thread 简单易用,但不灵活,无法继承其他类。
实现 Runnable 灵活,适合资源共享,避免了单继承的限制。
使用 Callable 可以返回结果,支持异常处理,适合需要获取线程执行结果的场景。

通常情况下,推荐使用 RunnableCallable 来创建线程,因为它们更加灵活,尤其是当需要共享资源或获取线程执行结果时。

举报

相关推荐

0 条评论