在java中如何实现多线程

实现多线程的方法

在Java中实现多线程主要有两种方式：继承Thread类和实现Runnable接口。Java 5之后还引入了Callable和Future接口，以及线程池的支持。

继承Thread类

通过继承Thread类并重写run()方法可以创建线程。run()方法包含线程执行的逻辑。

class MyThread extends Thread {
    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接口并实现run()方法。将实现了Runnable接口的实例传递给Thread类的构造函数。

class MyRunnable implements Runnable {
    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> {
    public String call() throws Exception {
        return "Callable task 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();
    }
}

使用线程池

线程池可以有效管理线程资源。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++) {
            Runnable worker = new WorkerThread("Task " + i);
            executor.execute(worker);
        }
        executor.shutdown();
    }
}

class WorkerThread implements Runnable {
    private String task;
    public WorkerThread(String task) {
        this.task = task;
    }
    public void run() {
        System.out.println(Thread.currentThread().getName() + " executing " + task);
    }
}

线程同步

在多线程环境下，共享资源的访问需要同步以避免数据不一致。可以使用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(counter.getCount());
    }
}

线程间通信

使用wait()、notify()和notifyAll()方法实现线程间通信。

class SharedResource {
    private boolean ready = false;
    public synchronized void produce() {
        ready = true;
        notify();
    }
    public synchronized void consume() throws InterruptedException {
        while (!ready) {
            wait();
        }
        System.out.println("Resource consumed");
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread producer = new Thread(resource::produce);
        Thread consumer = new Thread(() -> {
            try {
                resource.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        consumer.start();
        producer.start();
    }
}

以上方法涵盖了Java中实现多线程的基本方式，从简单的线程创建到复杂的线程同步和通信。根据具体需求选择合适的方法。