并发编程问题：Java多线程同步与死锁示例

原创小灰灰 2024-11-09 14:54 14阅读 0赞

在Java中，多线程编程时，同步和死锁是两个常见的问题。下面我将分别给出一个简单的同步示例和一个死锁示例。

### Java多线程同步示例同步是控制多个线程访问共享资源的一种机制。在Java中，可以通过`synchronized`关键字来实现同步。

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

public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return count;
 }
}

public class ThreadA extends Thread {
 private Counter counter;

public ThreadA(Counter counter) {
 this.counter = counter;
 }

public void run() {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 }
}

public class ThreadB extends Thread {
 private Counter counter;

public ThreadB(Counter counter) {
 this.counter = counter;
 }

public void run() {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 }

public static void main(String[] args) {
Counter counter = new Counter();
ThreadA threadA = new ThreadA(counter);
ThreadB threadB = new ThreadB(counter);

threadA.start();
 threadB.start();

try {
 threadA.join();
 threadB.join();
} catch (InterruptedException e) {
e.printStackTrace();
 }

System.out.println("Final count is: " + counter.getCount());
 }
}
```在这个示例中，`Counter`类有两个方法：`increment`和`getCount`，它们都被声明为`synchronized`，这意味着同一时间只有一个线程可以执行这些方法。`ThreadA`和`ThreadB`分别对`Counter`的`count`进行1000次增加操作。由于`increment`方法是同步的，所以最终`count`的值应该是2000。

### Java多线程死锁示例死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局。以下是一个简单的死锁示例：

```javapublic class DeadlockExample {
 public static void main(String[] args) {
Object lock1 = new Object();
Object lock2 = new Object();

Thread t1 = new Thread(() -> {
 synchronized (lock1) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Thread1 acquired both locks");
 }
 }
 });

Thread t2 = new Thread(() -> {
 synchronized (lock2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Thread2 acquired both locks");
 }
 }
 });

t1.start();
t2.start();
 }
}
```在这个示例中，`t1`和`t2`两个线程分别尝试获取两个不同的锁（`lock1`和`lock2`）。`t1`首先获取`lock1`，然后尝试获取`lock2`，而`t2`首先获取`lock2`，然后尝试获取`lock1`。由于两个线程都在等待对方释放锁，因此形成了死锁。

为了避免死锁，可以采取以下措施：

1.确保所有线程以相同的顺序获取锁。
2. 使用`tryLock`方法尝试获取锁，如果失败则释放已持有的锁。
3.限制持有锁的时间，使用超时机制。

希望这些示例能帮助你理解Java中的多线程同步和死锁问题。