synchronized ,ReentrantLock,ReentrantLock,CountDownLatch 在处理多线程并发问题的不同

本文链接：https://blog.youkuaiyun.com/javanewber/article/details/132189657

synchronized ：

synchronized 是 Java 编程语言中的一个关键字，用于实现多线程同步，确保多个线程在访问共享资源时能够按照一定的顺序执行，从而避免竞争条件和数据不一致的问题。

在 Java 中，当多个线程访问共享资源（如对象、方法或代码块）时，可能会发生竞争条件，导致数据损坏或不一致。synchronized 关键字的主要作用是确保在同一时间只有一个线程可以访问被同步的代码块或方法，从而保护共享资源的完整性。

Synchronized 关键字可以应用于以下几个层面：

实例方法同步：在实例方法前使用 synchronized 关键字，可以确保同一时间只有一个线程可以访问该方法。这对于保护实例变量的一致性非常有用。

代码示例：

public synchronized void synchronizedMethod() {
    // 同步代码块
}

静态方法同步：对于静态方法，您可以使用 synchronized 关键字，确保同一时间只有一个线程可以访问静态方法。这对于保护静态变量的一致性也非常有用。

代码示例：

public static synchronized void synchronizedStaticMethod() { 
           // 同步代码块 
}

代码块同步：您还可以在代码块内使用 synchronized 关键字，只同步特定的代码段，而不是整个方法。这样可以更精确地控制同步范围。

代码示例：

synchronized (sharedObject) {
        // 同步代码块 
}

需要注意的是，虽然 synchronized 关键字在某些情况下可以帮助解决多线程并发问题，但过度使用它可能会导致性能下降，因为同步操作可能会导致线程等待。在现代 Java 中，还有其他更高级的同步机制和并发工具，如 ReentrantLock、Semaphore、CountDownLatch 等，可以更灵活地处理多线程同步问题。

在使用 synchronized 关键字时，需要仔细考虑同步的范围和粒度，以及避免出现死锁等并发问题。

ReentrantLock：

ReentrantLock 是一个可重入的互斥锁，它允许线程多次获得同一个锁。与 synchronized 关键字不同，ReentrantLock 提供了更多的灵活性和控制。

代码示例：

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock();
    public void performTask() {
            lock.lock();
            try { 
               // 同步代码块 
              }finally { 
                  lock.unlock(); 
             } 
          }
    }

Semaphore：

Semaphore 是一个计数信号量，它可以控制同时访问某个资源的线程数量。以下是一个示例，其中 Semaphore 用于控制同时访问一个有限资源的线程数量：

import java.util.concurrent.Semaphore;

  public class SemaphoreExample {

    private Semaphore semaphore = new Semaphore(
        2);

    // 允许同时访问的线程数量为 
    public void performTask() throws InterruptedException {
      semaphore.acquire();
           // 获得许可
      try { 
            // 同步代码块 
         } finally {
             // 释放许可 
           semaphore.release();
 
      }
    }
  }

}

CountDownLatch：

CountDownLatch 是一个同步工具，它可以让一个或多个线程等待其他线程完成操作后再继续执行。其中使用 CountDownLatch 等待多个线程完成后再执行主线程：

代码示例：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public void performTask() throws InterruptedException {
        int numThreads = 3;
        CountDownLatch latch = new CountDownLatch(numThreads);

        for (int i = 0; i < numThreads; i++) {
            Thread thread = new WorkerThread(latch);
            thread.start();
        }

        latch.await(); // 等待所有线程完成
        System.out.println("All worker threads have completed.");
    }

    private static class WorkerThread extends Thread {
        private CountDownLatch latch;

        public WorkerThread(CountDownLatch latch) {
            this.latch = latch;
        }

        public void run() {
            // 执行任务
            latch.countDown(); // 任务完成后减少计数
        }
    }
}

如何使用 ReentrantLock、Semaphore 和 CountDownLatch 来处理多线程同步问题。在实际应用中，根据具体的需求和情况，选择适合的并发工具来解决多线程同步问题。