Java多线程同步问题实战

原创秒速五厘米 2024-10-25 13:45 32阅读 0赞

在Java多线程编程中，同步问题是一个关键难点。以下是一些实战问题及其解决方案：

1. 同步锁：如何使用synchronized关键字来保证对共享资源的互斥访问？

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

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new RuntimeException("Cannot decrement zero counter");
        }
    }

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

2. 唯一进入许可证（ULP）：如何使用wait/notify机制实现一个线程等待并被另一个线程唤醒？

```java
public class TicketSystem {
    private final Object lock = new Object();
    private int availableTickets = 10;

public void sellTicket(Thread currentThread) {
        synchronized (lock) {
            if (availableTickets > 0) {
                System.out.println("Ticket " + currentThread.getId() + " sold to Thread " + currentThread.getName());
                availableTickets--;
                lock.notifyAll();
                return true;
            } else {
                System.out.println("No ticket available for Thread " + currentThread.getName());
                return false;
            }
        }
    }

public void purchaseTicket(Thread currentThread) {
        synchronized (lock) {
            if (availableTickets > 0) {
                System.out.println("Ticket " + currentThread.getId() + " purchased by Thread " + currentThread.getName());
                availableTickets--;
                lock.notifyAll();
                return true;
            } else {
                System.out.println("No ticket available for Thread " + currentThread.getName());
                return false;
            }
        }
    }

public class TicketSoldExample {
        public static void main(String[] args) {
            Thread thread1 = new Thread(() -> { purchaseTicket(new Thread.currentThread())); }));
            Thread thread2 = new Thread(() -> { sellTicket(thread2)); }));

thread1.start();
            thread2.start();

try {
                thread1.join();
                thread2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```

3. 基于信号量的生产者-消费者问题：如何使用Semaphore实现一个线程安全的生产者-消费者模型？

```java
import java.util.concurrent.Semaphore;

public class ProducerConsumerExample {
    private final Semaphore producerSemaphore = new Semaphore(1);
    private final Semaphore consumerSemaphore = new Semaphore(0);

public void produce() throws InterruptedException {
        producerSemaphore.acquire();
        System.out.println("Producer " + Thread.currentThread().getId() + " is producing...");
        // 生产逻辑
        producerSemaphore.release();
    }

public void consume() throws InterruptedException {
        consumerSemaphore.acquire();
        System.out.println("Consumer " + Thread.currentThread().getId() + " is consuming...");
        // 消费逻辑
        consumerSemaphore.release();
    }

public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();

Thread producerThread = new Thread(() -> { example.produce(); }));
        Thread consumerThread1 = new Thread(() -> { example.consume(); })));
        Thread consumerThread2 = new Thread(() -> { example.consume(); })));

producerThread.start();
        consumerThread1.start();
        consumerThread2.start();

try {
            producerThread.join();
            consumerThread1.join();
            consumerThread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上就是Java多线程同步问题的一些实战案例，希望对你有所帮助。