java同步

Java中的同步是指在多线程编程中，用来控制多个线程对共享资源的访问，以避免数据不一致的问题。Java提供了多种同步机制来确保线程安全。以下是Java同步的详细讲解：

1. `synchronized`关键字

synchronized关键字是Java中最常见的同步机制，它可以用来同步方法或代码块。

同步方法

当一个方法被声明为synchronized时，线程必须获得该方法所属对象的锁才能执行这个方法。

public class Counter {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}

在上面的例子中，increment和getCount方法是同步的，这意味着同一时刻只有一个线程可以执行这两个方法中的任一个。

同步代码块

有时我们不需要同步整个方法，而只是需要同步方法中的某个部分。这时可以使用同步代码块。

public class Counter {private int count = 0;public void increment() {synchronized(this) {count++;}}public int getCount() {synchronized(this) {return count;}}
}

在上面的例子中，只同步了对共享资源count的操作部分，其他部分则不受同步的影响。

2. 锁对象

除了使用synchronized关键字，还可以使用显式锁对象来实现同步。Java提供了java.util.concurrent.locks包，其中包括多种锁实现。

ReentrantLock

ReentrantLock是一个可重入的互斥锁，功能比synchronized更强大和灵活。

import 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();}}
}

使用ReentrantLock需要手动获取和释放锁，通常使用try-finally块来确保锁在任何情况下都能被释放。

3. `volatile`关键字

volatile关键字用于声明变量，这样变量的值在多个线程间是可见的。它确保所有线程都能看到变量的最新值。

public class Counter {private volatile int count = 0;public void increment() {count++;}public int getCount() {return count;}
}

volatile保证了变量的可见性，但不保证操作的原子性。在多线程情况下，count++操作不是原子操作，因此仍可能会出现线程安全问题。

4. 并发工具类

Java的java.util.concurrent包提供了多种并发工具类来简化同步操作。

Atomic变量

AtomicInteger、AtomicLong等类提供了一些原子操作方法，确保操作的原子性。

import java.util.concurrent.atomic.AtomicInteger;public class Counter {private final AtomicInteger count = new AtomicInteger();public void increment() {count.incrementAndGet();}public int getCount() {return count.get();}
}

并发集合

Java提供了线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。

import java.util.concurrent.ConcurrentHashMap;public class ConcurrentMapExample {private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();public void put(String key, Integer value) {map.put(key, value);}public Integer get(String key) {return map.get(key);}
}

5. 高级同步工具

Java还提供了一些高级同步工具，如CountDownLatch、CyclicBarrier、Semaphore等。

CountDownLatch

CountDownLatch允许一个或多个线程等待，直到其他线程完成一组操作。

import java.util.concurrent.CountDownLatch;public class CountDownLatchExample {private static final int TASK_COUNT = 3;private final CountDownLatch latch = new CountDownLatch(TASK_COUNT);public void performTask() throws InterruptedException {// Perform some tasklatch.countDown();  // Decrement the count}public void awaitCompletion() throws InterruptedException {latch.await();  // Wait until the count reaches zero}
}

CyclicBarrier

CyclicBarrier允许一组线程互相等待，直到到达一个公共的屏障点。

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierExample {private final CyclicBarrier barrier = new CyclicBarrier(3);public void performTask() throws Exception {// Perform some taskbarrier.await();  // Wait until all parties have invoked await}
}

Semaphore

Semaphore控制对共享资源的访问，允许一定数量的许可。

import java.util.concurrent.Semaphore;public class SemaphoreExample {private final Semaphore semaphore = new Semaphore(3);public void performTask() throws InterruptedException {semaphore.acquire();  // Acquire a permittry {// Perform some task} finally {semaphore.release();  // Release the permit}}
}