java如何实现多线程

Java 多线程实现方法

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

继承 Thread 类

通过继承 Thread 类并重写 run() 方法实现多线程。创建子类实例后调用 start() 方法启动线程。

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

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

实现 Runnable 接口

实现 Runnable 接口并重写 run() 方法，将实现类实例作为参数传递给 Thread 类构造函数。

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

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

实现 Callable 接口

Callable 接口允许线程返回结果或抛出异常，通常与 ExecutorService 结合使用。

import java.util.concurrent.*;

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

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("Thread running");
            });
        }
        executor.shutdown();
    }
}

Lambda 表达式简化

Java 8 引入的 Lambda 表达式可以简化 Runnable 接口的实现。

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

线程同步与通信

使用 synchronized 关键字

synchronized 关键字用于实现线程同步，确保同一时间只有一个线程访问共享资源。

class Counter {
    private int count = 0;

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

使用 Lock 接口

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

使用 wait() 和 notify()

wait() 和 notify() 方法用于线程间通信，实现线程的等待和唤醒机制。

class SharedResource {
    private boolean ready = false;

    public synchronized void waitForReady() throws InterruptedException {
        while (!ready) {
            wait();
        }
    }

    public synchronized void setReady() {
        ready = true;
        notifyAll();
    }
}

线程安全集合类

Java 提供了多种线程安全的集合类，如 ConcurrentHashMap、CopyOnWriteArrayList 等。

import java.util.concurrent.ConcurrentHashMap;

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

线程异常处理

线程中的异常需要通过 UncaughtExceptionHandler 处理。

Thread thread = new Thread(() -> {
    throw new RuntimeException("Exception in thread");
});
thread.setUncaughtExceptionHandler((t, e) -> {
    System.out.println("Exception caught: " + e.getMessage());
});
thread.start();

以上方法涵盖了 Java 多线程的主要实现方式，开发者可以根据具体需求选择合适的方法。