当前位置：首页 > Java

如何在java中实现多线程

2026-03-04 03:02:38Java

实现多线程的三种方法

Java中实现多线程主要有三种方式：继承Thread类、实现Runnable接口、使用Callable和Future。每种方式适用于不同场景，可根据需求选择。

继承Thread类

通过继承Thread类并重写run()方法实现多线程。这种方式简单直接，但Java不支持多继承，因此若需继承其他类则无法使用。

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

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

实现Runnable接口

实现Runnable接口更灵活，适合需要多继承的场景。Runnable对象需要作为参数传递给Thread类的构造函数。

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

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

使用Callable和Future

Callable接口允许线程返回结果或抛出异常，通常配合ExecutorService和Future使用。这种方式适合需要获取线程执行结果的场景。

import java.util.concurrent.*;

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

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();
    }
}

线程池管理

使用线程池（如ThreadPoolExecutor）能有效管理线程生命周期和资源。线程池适用于需要频繁创建和销毁线程的场景。

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                System.out.println("Thread running from thread pool: " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}

线程同步

多线程访问共享资源时需同步处理，常用synchronized关键字或Lock接口保证线程安全。

如何在java中实现多线程

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + counter.getCount());
    }
}