Java多线程并发问题：线程同步与阻塞示例

原创忘是亡心i 2024-10-11 07:09 200阅读 0赞

在Java多线程编程中，线程同步和阻塞是两个重要的概念。下面分别给出这两个概念的示例。

1. 线程同步（Synchronization）

线程同步主要是通过锁机制来实现的。当一个线程获取到某个共享资源的锁后，其他线程就无法访问这个资源，这就达到了同步的效果。

示例代码：
```java
class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

public synchronized void increment() {
        count++;
        lock.unlock(); // unlock the lock before notify()
        lock.lock();
        notifyAll(); // wake up all waiting threads
    }

public synchronized void decrement() {
        if (count > 0) {
            count--;
            lock.unlock();
            lock.lock();
            notifyAll();
        }
    }

private class Waiter extends Thread {
        private final Object object;
        private final Waiter self;

public Waiter(Object object, Waiter self) {
            this.object = object;
            this.self = self;
        }

@Override
        public void run() {
            try {
                lock.lock();
                while (count == 0) {
                    if (!self.isInterrupted()) {
                        self.interrupt(); // interrupt the waiter thread
                    }
                    lock.unlock();
                    wait(object); // wait until notified by the lock
                    lock.lock();
                }
                count--;
                lock.unlock();
                notifyAll(); // wake up all waiting threads
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("Waiter interrupted.");
            } finally {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

public Waiter getWaiter() {
        return new Waiter(this, null));
    }
}
```
2. 线程阻塞（Blocking）

线程阻塞通常是由于调用了某些同步方法或代码，使得当前线程必须等待其他条件满足才能继续执行。

示例代码：
```java
public class BlockingExample {
    private final Object lock = new Object();

public void blockAndPrint() throws InterruptedException {
        synchronized (lock) { // Synchronized block
            System.out.println("Blocking thread before print.");
            lock.wait(); // Wait until notified by the lock
            System.out.println("Thread after print.");
        }
    }

public static void main(String[] args) throws InterruptedException {
        BlockingExample example = new BlockingExample();
        Thread blockingThread = new Thread(() -> {
            try {
                example.blockAndPrint();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

blockingThread.start(); // Start the blocking thread
        blockingThread.join(); // Wait for the blocking thread to finish
    }
}
```
在这个示例中，`BlockingExample`类中的`blockAndPrint`方法在获取到锁后进入阻塞状态。当锁被其他线程释放时，阻塞的线程就会被唤醒并继续执行后续代码。