java如何数据同步

数据同步方法

使用 synchronized 关键字

synchronized 是 Java 中最基本的数据同步机制，可以修饰方法或代码块，确保同一时间只有一个线程可以访问被保护的资源。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

使用 volatile 关键字

volatile 保证变量的可见性，当一个线程修改了 volatile 变量，其他线程能立即看到最新值。

public class SharedObject {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }
}

使用 Lock 接口

Java 并发包中的 Lock 接口提供了比 synchronized 更灵活的锁机制，如 ReentrantLock。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

使用原子类

Java 并发包中的原子类（如 AtomicInteger）提供原子操作，无需显式同步。

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }
}

使用并发集合

Java 并发包提供线程安全的集合类，如 ConcurrentHashMap。

import java.util.concurrent.ConcurrentHashMap;

public class Cache {
    private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

    public void put(String key, String value) {
        map.put(key, value);
    }
}

使用 CountDownLatch

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

import java.util.concurrent.CountDownLatch;

public class Worker implements Runnable {
    private final CountDownLatch latch;

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

    @Override
    public void run() {
        // 执行任务
        latch.countDown();
    }
}

使用 CyclicBarrier

CyclicBarrier 让一组线程互相等待，达到某个公共屏障点后再继续执行。

import java.util.concurrent.CyclicBarrier;

public class Task implements Runnable {
    private final CyclicBarrier barrier;

    public Task(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    @Override
    public void run() {
        try {
            // 执行任务
            barrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用 Semaphore

Semaphore 控制同时访问特定资源的线程数量。

import java.util.concurrent.Semaphore;

public class Pool {
    private Semaphore semaphore = new Semaphore(5);

    public void accessResource() {
        try {
            semaphore.acquire();
            // 访问资源
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}