实例分析：Java线程通信和同步机制问题

原创妖狐艹你老母 2024-11-11 11:21 1阅读 0赞

Java提供了多种线程通信和同步机制，以确保多线程程序的正确性和效率。以下是一些常见的线程通信和同步机制的实例分析：

1. **synchronized关键字**：
- **同步方法**：使用`synchronized`关键字可以同步整个方法，确保同一时间只有一个线程可以执行该方法。
- **同步代码块**：通过指定一个对象作为锁，可以只同步代码块，提高效率。
 ```java public class Counter {
 private int count =0;
 public synchronized void increment() {
 count++;
 }
 public synchronized int getCount() {
 return count;
 }
 }
 ```2. **Lock接口和ReentrantLock类**：
- `Lock`提供了比`synchronized`更灵活的锁定机制，如尝试非阻塞获取锁、可中断的锁获取等。
 ```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
 private final Lock lock = new ReentrantLock();
 private int count =0;
 public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }
 public int getCount() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
 }
 ```3. **volatile关键字**：
- `volatile`关键字确保变量的读写操作对所有线程都是可见的，即一个线程修改了变量的值，新值对其他线程立即可见。
 ```java public class Flag {
 private volatile boolean flag = false;
 public void setFlag() {
 flag = true;
 }
 public boolean isFlagSet() {
 return flag;
 }
 }
 ```4. **wait()和notify()/notifyAll()方法**：
-这些方法用于线程间的协作，`wait()`使当前线程等待，直到其他线程调用相同对象的`notify()`或`notifyAll()`。
 ```java public class BoundedBuffer {
 private final Object[] items = new Object[100];
 private int putPtr, takePtr, count;
 public synchronized void put(Object x) throws InterruptedException {
 while (count == items.length) wait();
 items[putPtr] = x;
if (++putPtr == items.length) putPtr =0;
++count;
 notify();
 }
 public synchronized Object take() throws InterruptedException {
 while (count ==0) wait();
Object x = items[takePtr];
if (++takePtr == items.length) takePtr =0;
--count;
 notify();
 return x;
 }
 }
 ```5. **Condition接口和await()/signal()方法**：
- `Condition`是`Lock`的扩展，提供了更灵活的线程等待/通知机制。
 ```javaimport java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBuffer {
 private final Object[] items = new Object[100];
 private int putPtr, takePtr, count;
 private final ReentrantLock lock = new ReentrantLock();
 private final Condition notFull = lock.newCondition();
 private final Condition notEmpty = lock.newCondition();

public void put(Object x) throws InterruptedException {
lock.lock();
 try {
 while (count == items.length) notFull.await();
 items[putPtr] = x;
if (++putPtr == items.length) putPtr =0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
 }
 }

public Object take() throws InterruptedException {
lock.lock();
 try {
 while (count ==0) notEmpty.await();
Object x = items[takePtr];
if (++takePtr == items.length) takePtr =0;
--count;
 notFull.signal();
 return x;
} finally {
lock.unlock();
 }
 }
 }
 ```6. **CountDownLatch和CyclicBarrier**：
- `CountDownLatch`用于一个或多个线程等待其他线程完成操作。
- `CyclicBarrier`用于一组线程相互等待，直到所有线程都到达某个屏障点。
 ```javaimport java.util.concurrent.CountDownLatch;

public class Main {
 public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);
 new Thread(() -> {
 System.out.println("Thread is running");
 latch.countDown();
 }).start();
 try {
 latch.await();
 System.out.println("Thread has finished");
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
 ```这些是Java中线程通信和同步的一些基本