如何实现java多线程

实现 Java 多线程的方法

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

继承 Thread 类

通过继承 Thread 类并重写 run() 方法可以实现多线程。创建一个新的类继承 Thread，并在 run() 方法中定义线程的任务。

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 接口并实现 run() 方法也可以实现多线程。这种方式更灵活，因为 Java 不支持多重继承，但可以实现多个接口。

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

使用 Callable 和 Future

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

import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Thread running with Callable and Future";
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        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(3);
        for (int i = 0; i < 5; i++) {
            Runnable worker = new WorkerThread("Task " + i);
            executor.execute(worker);
        }
        executor.shutdown();
    }
}

class WorkerThread implements Runnable {
    private String taskName;

    public WorkerThread(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(taskName + " is running by " + Thread.currentThread().getName());
    }
}

线程同步与安全

多线程环境下共享资源可能导致数据不一致问题，可以通过以下方式实现线程同步：

使用 synchronized 关键字

synchronized 可以修饰方法或代码块，确保同一时间只有一个线程访问共享资源。

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("Count: " + counter.getCount());
    }
}

使用 Lock 接口

Lock 接口提供了更灵活的锁机制，如 ReentrantLock。

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

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

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

    public int getCount() {
        return count;
    }
}

线程间通信

线程可以通过 wait()、notify() 和 notifyAll() 方法实现通信。

class SharedResource {
    private boolean ready = false;

    public synchronized void produce() {
        ready = true;
        System.out.println("Produced");
        notify();
    }

    public synchronized void consume() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Consumed");
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread producer = new Thread(resource::produce);
        Thread consumer = new Thread(resource::consume);
        consumer.start();
        producer.start();
    }
}

线程生命周期管理

线程的状态包括 NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING 和 TERMINATED。可以通过 Thread 类的方法管理线程生命周期。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("State: " + thread.getState()); // NEW
        thread.start();
        System.out.println("State: " + thread.getState()); // RUNNABLE
        Thread.sleep(500);
        System.out.println("State: " + thread.getState()); // TIMED_WAITING
        thread.join();
        System.out.println("State: " + thread.getState()); // TERMINATED
    }
}

通过以上方法，可以灵活实现 Java 多线程编程，并根据需求选择合适的同步机制和线程管理方式。