java如何实现多线程

实现多线程的方法

在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。此外，还可以使用ExecutorService等高级工具类来管理线程。

继承Thread类

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

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接口是更推荐的方式，因为Java不支持多重继承，而接口可以避免这一限制。实现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();
    }
}

使用ExecutorService

ExecutorService是Java提供的高级线程管理工具，可以更高效地管理线程池。

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

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

使用Callable和Future

如果需要线程返回结果，可以使用Callable和Future。Callable类似于Runnable，但可以返回结果或抛出异常。

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> "Result from Callable");
        System.out.println(future.get());
        executor.shutdown();
    }
}

使用Lambda表达式简化

Java 8及以上版本可以通过Lambda表达式简化线程的实现。

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

线程同步

多线程环境下，共享资源的访问可能导致数据不一致。可以通过synchronized关键字或Lock接口实现线程同步。

synchronized方法

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

synchronized块

class Counter {
    private int count = 0;
    public void increment() {
        synchronized(this) {
            count++;
        }
    }
}

使用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()和notifyAll()方法进行通信。

class SharedResource {
    private boolean ready = false;
    public synchronized void waitForReady() throws InterruptedException {
        while (!ready) {
            wait();
        }
    }
    public synchronized void setReady() {
        ready = true;
        notifyAll();
    }
}

线程池的最佳实践

使用线程池时，应根据任务类型选择合适的线程池配置。

• Executors.newFixedThreadPool(n)：固定大小的线程池。
• Executors.newCachedThreadPool()：根据需要创建线程，空闲线程会被回收。
• Executors.newSingleThreadExecutor()：单线程池，保证任务顺序执行。

避免直接使用new Thread()创建线程，以减少资源消耗和提高性能。