当前位置：首页 > Java

java如何实现多线程

2026-03-02 22:27:36Java

Java 多线程实现方法

Java 提供了多种实现多线程的方式，以下是常见的几种方法：

继承 Thread 类

通过继承 Thread 类并重写 run() 方法来实现多线程：

class MyThread extends Thread {
    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() 方法：

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

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

使用 Callable 和 Future

Callable 接口允许线程返回结果，通常与 Future 一起使用：

import java.util.concurrent.*;

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

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

使用线程池

Java 提供了 ExecutorService 来管理线程池：

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("Task executed by " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}

使用 CompletableFuture

Java 8 引入了 CompletableFuture 用于异步编程：

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Async task running");
        });
        future.join();
    }
}

线程同步方法

多线程环境下，同步机制是必要的：

synchronized 关键字

使用 synchronized 关键字实现同步：

class Counter {
    private int count = 0;

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

Lock 接口

使用 ReentrantLock 实现更灵活的同步：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private final Lock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

volatile 关键字

volatile 确保变量的可见性：

class SharedObject {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }
}

线程间通信

wait() 和 notify()

使用 wait() 和 notify() 进行线程间通信：

class Message {
    private String message;

    public synchronized void setMessage(String msg) {
        message = msg;
        notify();
    }

    public synchronized String getMessage() throws InterruptedException {
        while (message == null) {
            wait();
        }
        return message;
    }
}

线程安全集合

Java 提供了线程安全的集合类：

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("key", 1);
    }
}

这些方法涵盖了 Java 多线程编程的主要方面，可以根据具体需求选择合适的方式实现多线程。

java如何实现多线程