Java多线程同步的几种常见方法

目录

• Java多线程同步有哪些方法?
• 1. 使用 synchronized 关键字
• (1) 同步方法
• (2) 同步代码块
• 2. 使用 ReentrantLock
• 3. 使用 ReadwriteLock
• 4. 使用 volatile 关键字
• 5. 使用 Atomic 类
• 6. 使用 Semaphore（信号量）
• 7. 使用 CountDownLatch
• 8. 使用 CyclicBarrier
• 总结

Java多线程同步有哪些方法?

1. 使用 synchronized 关键字

synchronized 是 Java 提供的最基本的同步方式，它可以用来修饰方法或代码块，确保同一时刻只有一个线程能够执行被同步的代码部分。

(1) 同步方法

将整个方法标记为同步方法，确保同一时刻只有一个线程能够执行该方法。

public synchronized void method() {
    // 线程安全的操作
}

• 如果同步方法是实例方法，锁是当前实例对象（thiqyYOvzBs）。
• 如果同步方法是静态方法，锁是类对象（Class）。

(2) 同步代码块

通过同步代码块，指定一个特定的锁对象来控制同步的范围，从而提高性能。

public void method() {
    synchronized (this) {
        // 线程安全的操作
    }
}

this 表示锁住当前实例对象，可以根据需要使用不同的锁对象。

2. 使用 ReentrantLock

ReentrantLock 是 java.util.concurrent.locks 包中的一个锁实现，提供比 synchronized 更加灵活和强大的功能，如可重入性、公平性、响应中断等。通过显式调用 lock() 和 unlock() 来控制锁的获取和释放。

import java.util.concurrent.locks.ReentrantLock;
 
public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
 
    public void method() {
        lock.lock();
        try {
            // 线程安全的操作
        } finally {
            lock.unlock();
        }
    }
}

特性：

• 可重入性：同一线程可以多次获得锁。
• 公平性：编程客栈可以选择公平锁（按请求顺序获取锁）。
• 中断响应：支持响应线程中断。

3. 使用 ReadWriteLock

ReadWriteLock 是 java.util.concurrent.locks 包中的一个接口，分为 ReentrantReadWriteLock 实现类。它提供了读写锁机制，其中允许多个线程同时读，但写操作是互斥的，保证了高效的读操作并避免写操作冲突。

import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
    public void readMethod() {
        lock.readLock().lock();
        try {
            // 线程安全的读操作
        } finally {
            lock.readLock().unlock();
        }
    }
 
    public void writeMethod() {
        lock.writeLock().lock();
        try {
            // 线程安全的写操作
        } finally {
            lock.writeLock().unlock();
        }
    }
}

特性：

• 读锁：多个线程可以android同时获得读锁，只要没有写锁被占用。
• 写锁：写锁是独占的，当一个线程获取写锁时，其他线程不能同时获得读锁或写锁。

4. 使用 volatile 关键字

volatile 关键字用于确保线程对某个变量的修改对其他线程立即可见。volatile 保证了变量的可见性，但并不能保证原子性。

private volatile boolean flag = false;

• 可见性：确保线程对 volatile 变量的修改立即对其他线程可见。
• 不保证原子性：对于复合操作（如 i++），volatile 并不能保证原子性。

5. 使用 Atomic 类

java.util.concurrent.atomic 包提供了一些原子操作类，如 AtomicInteger、AtomicBoolean 等，适用于处理简单的数值操作。它们通过 CAS（比较并交换）机制提供原子操作，避免了使用锁。

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

• 原子性：这些类通过底层的 CAS 操作保证线程安全。
• 无锁机制：避免了传统锁的性能开销。

6. 使用 Semaphore（信号量）

Semaphore 是一种用来控制同时访问特定资源的线程数的同步工具。它可以设置一个信号量计数，控制可以访问某些资源的线程数量。

import java.util.concurrent.Semaphore;
 
public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3); // 最大允许3个线程
 
    public void AccessResource() {
        try {
            semaphore.acquire();
            // 执行资源访问操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

• 可控制并发数：通过信号量来控制并发线程数。
• 适用场景：用于限制某些共享资源的并发访问，例如数据库连接池等。

7. 使用 CountDownLatch

CountDownLatch 是一种同步工具，允许一个或多个线程等待，直到其他线程完成一组操作后再继续执行。通常用于在一组线程完成任务后再启动主线程或其他线程。

import java.util.concurrent.CountDownLatch;
 
public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3); // 等待3个线程完成
 
    public void task() {
        try {
            // 执行某些操作
        } finally {
            latch.countDown(); // 操作完成，计数减一
        }
    }
 
    public void mainTask() throws InterruptedException {
        latch.await(); // 等待所有线程完成
        System.out.println("All tasks are finished!");
    }
}

8. 使用 CyclicBarrier

CyclicBarrier 是一个允许一组线程互相等待，直到所有线程都到达某个公共屏障点后再继续执行的同步工具。它适用于需要多线程并行执行的场景。

import java.util.concurrent.CyclicBarrier;
 
public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
        @Override
        public void run() {
            System.out.println("All threads reached the barrier, continue execution.");
        }
    });
 
    public void task() throws InterruptedException {
        barrier.await(); // 等待所有线程到达屏障编程客栈
        // 执行任务
    }
}

总结

Java 提供了多种同步机制来保证多线程环境下的线程安全，具体使用哪种方法，取决于实际的应用场景：

• synchronized：简单易用，但性能较低。
• ReentrantLock：提供更灵活的锁控制。
• ReadWriteLock：适用于读多写少的场景。
• volatile：用于保证变量的可见性，但不适用于复合操作。
• Atomic 类：适用于简单的原子操作，避免了锁的使用。
• Semaphore：控制并发线程数量。
• CountDownLatch 和 CyclicBarrier：用于线程间协调与同步。

这些方法都可以在不同的场景下帮助我们实现线程安全与高效的并发控制。

以上就是Java多线程同步的几种常见方法的详细内容，更多关于Java多线程同步方法的资料请关注编程客栈(www.devze.com)其它相关文章！