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

原创偏执的太偏执、 2024-11-29 11:45 1阅读 0赞

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

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

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

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

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

以上示例展示了如何通过synchronized关键字避免死锁，并在两个线程中演示了同步操作。