如何在java中实现多线程

实现多线程的两种核心方法

在Java中，多线程的实现主要通过继承Thread类或实现Runnable接口来完成。这两种方法各有特点，适用于不同场景。

继承Thread类 通过继承Thread类并重写run()方法，可以创建自定义线程类。以下是示例代码：

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

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

实现Runnable接口 实现Runnable接口是更推荐的方式，因为Java不支持多重继承。这种方式更灵活：

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

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

使用Lambda表达式简化实现

Java 8以后，可以通过Lambda表达式更简洁地实现Runnable接口：

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

线程池的使用

对于需要管理多个线程的场景，使用线程池是更高效的方式。Java提供了ExecutorService框架：

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

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: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

线程同步与安全

多线程环境下需要注意线程安全问题，可以使用synchronized关键字或Lock接口：

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

线程间通信

使用wait()和notify()方法可以实现线程间通信：

class Message {
    private String msg;

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

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

以上方法涵盖了Java多线程编程的主要方面，从基础实现到高级特性，可以根据具体需求选择合适的方式。