Java中的同步工具类：理解和使用问题实例

原创左手的ㄟ右手 2024-11-06 19:00 48阅读 0赞

Java中的同步工具类主要是指`java.util.concurrent`包中的一些类，它们提供了比传统`synchronized`关键字更高级的同步机制。以下是一些常见的同步工具类及其使用场景和问题实例：

1. **CountDownLatch**
- **用途**：用于一个或多个线程等待一组操作在其他线程中完成。
- **问题实例**：假设有5个任务需要执行，主线程需要等待这5个任务完成后才能继续执行。
- **代码示例**：
 ```javaCountDownLatch latch = new CountDownLatch(5);
 for (int i =0; i <5; i++) {
 new Thread(() -> {
//执行任务 System.out.println("任务执行完毕");
 latch.countDown();
 }).start();
 }
 latch.await(); // 主线程等待所有任务完成 System.out.println("所有任务完成，主线程继续执行");
 ```2. **CyclicBarrier**
- **用途**：用于一组线程互相等待，直到所有线程都到达某个公共屏障点。
- **问题实例**：有多个线程需要执行一系列任务，每个任务完成后，所有线程需要在下一个任务开始前同步。
- **代码示例**：
 ```javaCyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("所有线程到达屏障"));
 for (int i =0; i <3; i++) {
 new Thread(() -> {
 try {
 System.out.println(Thread.currentThread().getName() + "执行任务1");
Thread.sleep(1000);
 barrier.await();
 System.out.println(Thread.currentThread().getName() + "执行任务2");
} catch (Exception e) {
e.printStackTrace();
 }
 }).start();
 }
 ```3. **Semaphore**
- **用途**：用于控制同时访问某个特定资源的线程数量。
- **问题实例**：有10个线程需要访问数据库，但数据库同时只能支持3个并发连接。
- **代码示例**：
 ```javaSemaphore semaphore = new Semaphore(3);
 for (int i =0; i <10; i++) {
 new Thread(() -> {
 try {
 semaphore.acquire();
 System.out.println(Thread.currentThread().getName() + "正在访问数据库");
Thread.sleep(1000);
 semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }).start();
 }
 ```4. **ReentrantLock**
- **用途**：可重入锁，比`synchronized`关键字更灵活。
- **问题实例**：需要在多个方法中同步访问共享资源，且这些方法可能相互调用。
- **代码示例**：
 ```javaReentrantLock lock = new ReentrantLock();
 public void methodA() {
lock.lock();
 try {
//执行操作 methodB();
} finally {
lock.unlock();
 }
 }
 public void methodB() {
lock.lock();
 try {
//执行操作} finally {
lock.unlock();
 }
 }
 ```5. **ReadWriteLock**
- **用途**：读写锁，允许多个读操作同时进行，但写操作是独占的。
- **问题实例**：一个资源被多个线程频繁读取，但很少写入。
- **代码示例**：
 ```javaReadWriteLock lock = new ReentrantReadWriteLock();
 public void read() {
lock.readLock().lock();
 try {
//执行读操作} finally {
lock.readLock().unlock();
 }
 }
 public void write() {
lock.writeLock().lock();
 try {
//执行写操作} finally {
lock.writeLock().unlock();
 }
 }
 ```使用这些同步工具类时，需要注意以下几点：
-确保在finally块中释放锁，避免死锁。
-避免在持有锁的情况下执行长时间操作，以免影响系统性能。
-合理选择同步工具类，根据实际需求和场景选择最合适的同步机制。