浅谈Java中线程同步问题案例

原创迷南。 2024-11-14 17:42 20阅读 0赞

在Java编程中，线程同步问题主要涉及互斥、条件等待和死锁等概念。下面通过几个案例来具体解释。

1. 互斥：当一个资源（如锁）只能被一个线程访问时，就存在互斥问题。例如：

```java
class Counter {
    private int count = 0;

synchronized void increment() {
        count++;
    }

synchronized int getCount() {
        return count;
    }
}

// 线程A尝试增加计数
Thread t1 = new Thread(() -> {
    Counter counter = new Counter();
    for (int i = 0; i < 5; i++) {
        counter.increment();
    }
}));
t1.start();

// 线程B查看计数
Thread t2 = new Thread(() -> {
    Counter counter = new Counter();
    try {
        System.out.println("当前计数: " + counter.getCount());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t2.start();
```

2. 条件等待：当一个线程在某个条件满足之前，无法执行任何操作时，就可能发生条件等待。例如：

```java
class waiter {
    private final Object lock;
    private boolean condition = false;

waiter(Object lock) {
        this.lock = lock;
    }

synchronized void waitCondition() throws InterruptedException {
        while (!condition) {
            // 模拟耗时操作
            Thread.sleep(100);
            if (Thread.interrupted()) {
                throw new InterruptedException("中断");
            }
        }
        System.out.println("条件满足，唤醒线程");
        condition = false;  // 清除条件
    }

synchronized void signal() {
        condition = true;  // 设置条件
    }
}

// 线程A等待条件
Thread t1 = new Thread(() -> {
    waiter waiter = new waiter(new Object());
    try {
        waiter.waitCondition();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t1.start();

// 线程B设置条件，唤醒线程A
Thread t2 = new Thread(() -> {
    waiter waiter = new waiter(new Object());
    try {
        waiter.signal();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t2.start();
```

3. 死锁：在多线程环境下，如果两个或多个线程互相等待对方释放资源，就会形成死锁。例如：

```java
class BankAccount {
    private int balance = 0;

synchronized void deposit(int amount) {
        if (amount > 0 && balance + amount < Integer.MAX_VALUE) {
            balance += amount;
            System.out.println("存款成功，当前余额: " + balance);
        } else {
            System.out.println("存款金额无效，请输入正整数");
        }
    }

synchronized void withdraw(int amount) {
        if (amount > 0 && balance - amount >= 0) {
            balance -= amount;
            System.out.println("取款成功，当前余额: " + balance);
        } else {
            System.out.println("取款金额无效，请输入正整数");
        }
    }

public static void main(String[] args) {
        BankAccount account1 = new BankAccount();
        BankAccount account2 = new BankAccount();

// 线程A存款到账户1
        Thread t1a = new Thread(() -> {
            account1.deposit(50);
        }));
        t1a.start();

// 线程B从账户1取款，同时存入账户2
        Thread t1b = new Thread(() -> {
            account1.withdraw(30);  // 先取走一部分
            account2.deposit(20);  // 再存款到账户2
        }));
        t1b.start();

// 等待线程B执行完毕
        try {
            t1b.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上案例展示了线程同步问题的基本类型，包括互斥、条件等待和死锁。在实际开发中，要根据具体场景合理使用锁（synchronized）、信号量（Semaphore）等同步机制。