Java 中线程同步的几种方式

拼搏现实的明天。 2024-03-22 10:51 4阅读 0赞

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 中线程同步的几种方式。在多线程编程中，选择合适的线程同步技术可以提高程序的性能和可靠性。