当前位置：首页 > Java

java如何启动线程

2026-03-03 10:11:38Java

启动线程的方法

在Java中，启动线程可以通过多种方式实现。以下是常见的几种方法：

继承Thread类

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

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

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

实现Runnable接口

创建一个类实现Runnable接口，并实现run()方法。将Runnable实例传递给Thread构造函数，再调用start()方法启动线程。

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

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

使用Lambda表达式

通过Lambda表达式简化Runnable接口的实现，直接传递给Thread构造函数。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        thread.start();
    }
}

使用Executor框架

通过ExecutorService管理线程池，提交Runnable或Callable任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(() -> {
            System.out.println("Thread is running");
        });
        executor.shutdown();
    }
}

实现Callable接口

实现Callable接口并返回结果，通过Future获取线程执行结果。

import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Thread is running";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get());
        executor.shutdown();
    }
}