理解和解决Java多线程并发问题示例-蒲公英云

理解和解决Java多线程并发问题示例

在Java中，多线程并发问题主要涉及到线程同步、死锁、活锁等问题。下面是一些示例：

线程同步：通过synchronized关键字来实现线程互斥。例如：

class Counter {
    private int count = 0;
    synchronized void increment() {
        count++;
    }
    synchronized int getCount() {
        return count;
    }
}
public class ThreadSyncExample {
    public static void main(String[] args) {
        Counter counter = new Counter();
        // 创建两个线程，分别增加和获取计数
        Thread threadIncrement = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        }));
        Thread threadGetCount = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Current count: " + counter.getCount());
            }
        }));
        // 启动线程
        threadIncrement.start();
        threadGetCount.start();
        // 等待所有线程执行完毕
        try {
            threadIncrement.join();
            threadGetCount.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

死锁：当两个或更多线程相互等待对方持有的资源时，就会发生死锁。例如：

class DeadlockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();
    public void thread1() throws InterruptedException {
        synchronized (lock1) {
            System.out.println("Thread 1 acquired lock1");
            // 等待获取锁2
            synchronized (lock2) {
                System.out.println("Thread 1 acquired lock2");
                // 此时线程已经完成所有操作，释放资源
                lock2.notify();
            }
        }
    }
    public void thread2() throws InterruptedException {
        synchronized (lock2) {
            System.out.println("Thread 2 acquired lock2");
            // 等待获取锁1
            synchronized (lock1) {
                System.out.println("Thread 2 acquired lock1");
                // 此时线程已经完成所有操作，释放资源
                lock1.notify();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        DeadlockExample example = new DeadlockExample();
        Thread thread1 = new Thread(() -> {
            try {
                example.thread1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        Thread thread2 = new Thread(() -> {
            try {
                example.thread2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        // 启动线程
        thread1.start();
        thread2.start();
        // 等待所有线程执行完毕
        thread1.join();
        thread2.join();
    }
}