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

更新时间：2025年05月13日 10:12:35 作者：java1234_小锋

在 Java 中,多线程同步是确保多个线程在访问共享资源时不会发生竞争和冲突的机制,Java 提供了多种方式来实现线程同步,以下是 Java 中常见的几种同步方法,需要的朋友可以参考下

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

1. 使用 synchronized 关键字

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

(1) 同步方法

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

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

如果同步方法是实例方法，锁是当前实例对象（this）。
如果同步方法是静态方法，锁是类对象（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();
        }
    }
}

特性：

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

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 AtomicInteger 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多线程同步方法的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

Java高效读取大文件实例分析
这篇文章主要介绍了Java高效读取大文件实例分析，具有一定借鉴价值,需要的朋友可以参考下
2018-01-01
JavaWeb项目中springmvc和tomcat对静态文件的处理
这篇文章主要介绍了JavaWeb项目中springmvc和tomcat对静态文件的处理的相关资料,需要的朋友可以参考下
2016-07-07
学习Java之如何对时间进行格式化
当我们在默认情况下构造出来的时间对象，它的时间格式并不适合我们阅读，并且在开发时，pc端、Android端、iOS端等展示的时间格式可能也并不完全一样，本文就从这几个问题给大家介绍如何对时间进行格式化，感兴趣的同学可以借鉴一下
2023-05-05
java线程之使用Runnable接口创建线程的方法
本篇文章介绍了，java中使用Runnable接口创建线程的方法。需要的朋友参考下
2013-05-05
java 发送http和https请求的实例
下面小编就为大家分享一篇java 发送http和https请求的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-01-01
简单了解JAVA public class与class区别
这篇文章主要介绍了简单了解JAVA public class与class区别,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-03-03
ScheduledExecutorService任务定时代码示例
这篇文章主要介绍了ScheduledExecutorService任务定时代码示例，具有一定借鉴价值,需要的朋友可以参考下
2018-01-01
基于Java编写一个通用返回工具类Result
Java项目搭建时，常常需要去封装一个通用型的Result工具类，下面小编就和大家分享一个已经封装好的常用的返回类，希望对大家有所帮助
2023-07-07
springboot 1.5.2 集成kafka的简单例子
本篇文章主要介绍了springboot 1.5.2 集成kafka的简单例子，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-11-11
Springboot项目登录校验功能实现
本文介绍了Web登录校验的重要性,对比了Cookie、Session和JWT三种会话技术,分析其优缺点,并讲解了过滤器与拦截器的统一拦截方案,推荐使用JWT结合拦截器实现安全、高效的登录校验,下面通过实例代码讲解Springboot项目的登录校验实现,感兴趣的朋友一起看看吧
2025-08-08