Java 中线程同步的几种方式

Java 中的多线程编程是一种复杂的任务，因为多线程程序必须处理并发问题。Java 提供了多种线程同步技术，可以帮助开发人员编写高效的多线程程序。本文将介绍 Java 中线程同步的几种方式，并提供相应的代码示例。

synchronized 关键字

synchronized 关键字是 Java 中最常用的线程同步技术之一。使用 synchronized 关键字可以确保同一时刻只有一个线程访问共享资源。synchronized 关键字可以用于方法或代码块中。

方法同步：

class ThreadSafeCounter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

代码块同步：

class ThreadSafeCounter {
    private int count = 0;

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

    public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

ReentrantLock 类

ReentrantLock 类是 Java 中提供的另一种线程同步技术。ReentrantLock 类提供了与 synchronized 关键字类似的功能，但比 synchronized 更灵活。ReentrantLock 类中的 lock() 方法用于获取锁，unlock() 方法用于释放锁。

import java.util.concurrent.locks.ReentrantLock;

class ThreadSafeCounter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

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

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

AtomicInteger 类

AtomicInteger 类是 Java 中提供的一种原子类型。原子类型是线程安全的，并且可以保证在多线程环境下的正确性。AtomicInteger 类中的 incrementAndGet() 方法用于原子递增操作。

import java.util.concurrent.atomic.AtomicInteger;

class ThreadSafeCounter {
    private AtomicInteger count = new AtomicInteger(0);

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

    public int getCount() {
        return count.get();
    }
}

volatile 关键字

volatile 关键字用于保证共享变量在线程之间的可见性。在多线程环境下使用 volatile 关键字可以避免出现数据不一致的情况。

java

Copy

class ThreadSafeCounter {
    private volatile int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

synchronized 集合类

Java 中提供了几种线程安全的集合类，如 ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue 等。这些集合类使用 synchronized 关键字实现线程同步。

import java.util.concurrent.ConcurrentHashMap;

class ThreadSafeCounter {
    private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void increment(String key) {
        map.put(key, map.getOrDefault(key, 0) + 1);
    }

    public int getCount(String key) {
        return map.get(key);
    }
}

以上就是 Java 中线程同步的几种方式。在多线程编程中，选择合适的线程同步技术可以提高程序的性能和可靠性。