Java并发编程：锁和同步问题示例

原创川长思鸟来 2024-11-28 01:45 22阅读 0赞

在Java中，线程间的协作主要通过锁（Lock）和同步机制（Synchronization）来实现。下面提供几个具体的示例：

1. **独占锁**（Synchronized on object）
   ```java
   class Counter {
       private int count = 0;

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

public synchronized int decrement() {
           if (count > 0) {
               count--;
               return count;
           } else {
               throw new IllegalArgumentException("Counter is already at zero.");
           }
       }

// Getter
       public synchronized int getCount() {
           return count;
       }
   }
   ```
   
2. **公平锁**（Synchronized on object with fairness）
   ```java
   class FairQueue {
       private int size = 0;
       private Object[] queue;

// Constructor
       public FairQueue(int capacity) {
           this.queue = new Object[capacity];
       }

// Add item to the end of the queue
       public synchronized void enqueue(Object item) {
           if (size == queue.length) {
               resize(queue.length * 2); // Resize based on fairness
           }
           queue[size++] = item;
           notifyAll(); // Notify waiting threads
       }

// Remove and return an item from the front of the queue
       public synchronized Object dequeue() {
           while (size == 0) { // Wait if queue is empty
               try {
                   wait();
               } catch (InterruptedException e) {
                   Thread.currentThread().interrupt(); // Handle interruption
                   e.printStackTrace();
               }
           }
           Object item = queue[size--];
           notifyAll(); // Notify waiting threads
           return item;
       }

// Get the size of the queue
       public synchronized int getSize() {
           return size;
       }
   }
   ```
   
3. **死锁**（ deadlock）
   在多线程环境中，如果两个或多个线程在执行过程中，因竞争资源而造成的一种相互等待的现象叫死锁。

以上示例展示了Java中如何使用锁和同步机制来控制多线程的交互。