在Java中，同步方法是通过使用synchronized关键字来实现的，当一个线程访问一个对象的同步方法时，它会获得该对象的内部锁（也称为监视器锁），如果另一个线程已经获得了该对象的锁并正在执行同步方法，那么其他试图访问该对象同步方法的线程将被阻塞，直到第一个线程释放锁。Java中同步方法主要有两种形式：静态同步方法和实例同步方法。1. 静态同步方法：使用类名作为锁对象，当一个线程访问一个类的静态同步方法时，它会获取该类的锁，由于类锁是共享的，因此静态同步方法在多线程环境中可以有效地控制对静态资源的访问。2. 实例同步方法：使用对象实例作为锁对象，当一个线程访问一个对象的实例同步方法时，它会获取该对象的锁，由于每个对象实例都有自己的锁，因此实例同步方法在多线程环境中可以针对特定对象进行同步。在Java中，通过使用synchronized关键字，我们可以轻松地实现方法的同步，从而确保多线程环境下的数据一致性和安全性。
本文目录导读：
在Java编程中，同步是一个非常重要的概念，特别是在多线程环境下，同步方法是为了防止多个线程同时访问共享资源时出现数据不一致的问题，本文将详细介绍Java中常见的几种同步方法,并通过案例和问答的形式帮助大家更好地理解和应用这些知识。
同步方法（Synchronized Methods）
同步方法是使用synchronized关键字修饰的方法，当一个线程访问同步方法时,其他线程必须等待当前线程执行完毕后才能访问该方法。
示例代码：
public class SynchronizedMethodExample {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
在这个例子中，increment()和getCount()方法都被声明为同步方法,因此同一时间只有一个线程可以执行这两个方法中的一个。
问答：
-
问：同步方法有什么优点？
答：同步方法可以确保多个线程对共享资源的访问是互斥的,从而避免数据不一致的问题。
-
问：同步方法有什么缺点？
答：同步方法会降低程序的并发性能,因为线程需要等待当前线程执行完毕后才能继续执行。
同步代码块（Synchronized Blocks）
同步代码块是使用synchronized关键字和一个对象锁来同步代码，与同步方法类似,同步代码块也可以确保同一时间只有一个线程可以访问被保护的代码块。
示例代码：
public class SynchronizedBlockExample {
private int count = 0;
private final Object lock = new Object();
public void increment() {
synchronized (lock) {
count++;
}
}
public int getCount() {
synchronized (lock) {
return count;
}
}
}
在这个例子中，我们使用了一个私有的Object对象lock作为锁，确保对count变量的访问是线程安全的。
问答：
-
问：同步代码块和同步方法有什么区别？
答：同步代码块允许更细粒度的控制，可以只保护部分代码,而同步方法则会锁定整个方法。
-
问：同步代码块的使用场景是什么？
答：同步代码块适用于需要保护部分代码的场景,例如只保护某个变量的读写操作。
ReentrantLock（可重入锁）
ReentrantLock是java.util.concurrent.locks包中的一个类，它提供了比synchronized更灵活的线程同步机制。ReentrantLock支持公平锁和非公平锁，并且提供了更多的控制选项，如尝试获取锁、定时获取锁等。
示例代码：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
在这个例子中，我们使用ReentrantLock来保护对count变量的访问,确保线程安全。
问答：
-
问：ReentrantLock和synchronized有什么区别？
- 答：
ReentrantLock提供了更灵活的线程同步机制，支持公平锁和非公平锁,并且提供了更多的控制选项。
- 答：
-
问：ReentrantLock的使用场景是什么？
- 答：
ReentrantLock适用于需要更复杂锁策略的场景，例如需要公平锁、定时获取锁或者尝试获取锁等。
- 答：
ReadWriteLock（读写锁）
ReadWriteLock是java.util.concurrent.locks包中的一个接口，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源,这种锁适用于读操作远多于写操作的场景。
示例代码：
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockExample {
private int count = 0;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public void increment() {
lock.writeLock().lock();
try {
count++;
} finally {
lock.writeLock().unlock();
}
}
public int getCount() {
lock.readLock().lock();
try {
return count;
} finally {
lock.readLock().unlock();
}
}
}
在这个例子中，我们使用ReadWriteLock来保护对count变量的访问，允许多个线程同时读取count，但只允许一个线程写入count。
问答：
-
问：ReadWriteLock的使用场景是什么？
- 答：
ReadWriteLock适用于读操作远多于写操作的场景,可以提高并发性能。
- 答：
-
问：ReadWriteLock和ReentrantLock有什么区别？
- 答：
ReadWriteLock专门用于读写操作的同步，而ReentrantLock提供了更灵活的锁策略。
- 答：
案例说明
假设我们有一个银行账户类BankAccount，多个线程可能会同时对该账户进行存款和取款操作，为了确保账户余额的正确性,我们可以使用同步方法或同步代码块来保护对账户余额的访问。
示例代码：
public class BankAccount {
private double balance;
public synchronized void deposit(double amount) {
balance += amount;
}
public synchronized void withdraw(double amount) {
if (balance >= amount) {
balance -= amount;
} else {
throw new IllegalArgumentException("Insufficient funds");
}
}
public synchronized double getBalance() {
return balance;
}
}
在这个例子中，我们对deposit()、withdraw()和getBalance()方法进行了同步,确保多个线程对账户余额的访问是互斥的。
通过以上介绍，相信大家对Java中的同步方法有了更深入的了解，在实际编程中，我们需要根据具体的场景选择合适的同步方式,以确保程序的正确性和性能。
知识扩展阅读
什么是同步？
在多线程环境下，多个线程可能会同时访问共享资源，比如一个全局变量、一个数据库连接、一个文件等等，如果多个线程同时修改同一个变量，就可能出现数据不一致、竞态条件等问题，而同步，就是用来控制多个线程对共享资源的访问顺序，确保在任意时刻,只有一个线程能够访问某个资源。
Java中的同步方法有哪些？
下面我们来逐一介绍Java中常用的同步方法，每个方法我们都从原理、使用方式、适用场景三个方面进行讲解。
synchronized 关键字
这是Java中最基础也是最常用的同步方法，它可以通过方法或代码块来实现同步。
使用方式：
// 同步方法
public synchronized void deposit(int amount) {
balance += amount;
}
// 同步代码块
public void transfer(Account target, int amount) {
synchronized(this) {
balance -= amount;
}
synchronized(target) {
target.balance += amount;
}
}
原理：
synchronized 关键字会加锁,同一时刻只有一个线程可以执行被锁住的代码块或方法。
优点：
- 使用简单,无需手动释放锁。
- 内置在JVM中，性能相对较好（在早期版本中）。
缺点：
- 不支持中断、超时等高级功能。
- 锁升级机制复杂,可能影响性能。
ReentrantLock（重入锁）
这是java.util.concurrent.locks包中的一个类，提供了比synchronized 更灵活的锁机制。
使用方式：
ReentrantLock lock = new ReentrantLock();
public void deposit(int amount) {
lock.lock();
try {
balance += amount;
} finally {
lock.unlock(); // 一定要在finally中释放锁
}
}
原理：
ReentrantLock 是一个可重入的互斥锁,支持公平锁和非公平锁。
优点：
- 支持可中断、超时等待。
- 支持公平锁，避免“线程饥饿”。
- 可以获取锁的状态。
缺点：
- 使用相对复杂,需要手动释放锁。
- 需要处理异常,避免死锁。
volatile 关键字
volatile 主要用于可见性保证，它不能保证原子性,但能确保多个线程对共享变量的操作是可见的。
使用方式：
public class Flag {
private volatile boolean isRunning = true;
public void run() {
while (isRunning) {
// 执行任务
}
}
public void stop() {
isRunning = false;
}
}
原理：
volatile 会禁止指令重排，并且每次读写操作都会直接从主内存中读写,而不是从线程的本地缓存中读取。
适用场景：
- 适用于状态标记（如停止标志、通知标志）。
- 不适用于需要原子操作的场景（如计数器）。
Atomic 类（原子类）
java.util.concurrent.atomic 包提供了原子操作类，如 AtomicInteger、AtomicLong、AtomicReference 等。
使用方式：
AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // 原子性递增
原理：
基于 CAS（Compare-And-Swap）操作实现，无锁操作,避免了使用锁带来的开销。
优点：
- 高性能,适合高并发场景。
- 简单易用,无需手动加锁。
缺点：
- 不能用于复合操作（如转账操作需要多个步骤）。
- 不支持超时、中断等高级功能。
BlockingQueue
BlockingQueue 是 Java 并发包中的一种队列，它支持线程安全的队列操作，并且在队列为空或满时,线程会自动阻塞。
使用方式：
ArrayBlockingQueue queue = new ArrayBlockingQueue<>(10);
// 生产者
new Thread(() -> {
while (true) {
queue.put("任务");
}
}).start();
// 消费者
new Thread(() -> {
while (true) {
String task = queue.take();
// 处理任务
}
}).start();
适用场景：
- 生产者-消费者模型。
- 线程池中的任务队列。
StampedLock
这是 Java 8 新增的锁，提供了读写锁分离，并且支持公平锁和不可中断模式。
使用方式：
StampedLock lock = new StampedLock();
public void writeOp() {
long stamp = lock.writeLock();
try {
// 写操作
} finally {
lock.unlockWrite(stamp);
}
}
优点：
- 支持读写锁分离，读锁不阻塞读,写锁阻塞所有。
- 性能优于
ReentrantReadWriteLock。
同步方法对比表
| 方法 | 是否可重入 | 是否公平 | 是否支持中断 | 是否支持超时 | 是否支持读写锁分离 | 适用场景 |
|---|---|---|---|---|---|---|
synchronized |
是 | 否 | 否 | 否 | 否 | 基础同步 |
ReentrantLock |
是 | 是/否 | 是 | 是 | 否 | 高级同步 |
volatile |
否 | 否 | 否 | 否 | 否 | 状态标记 |
Atomic 类 |
是 | 否 | 否 | 否 | 否 | 原子操作 |
BlockingQueue |
否 | 否 | 否 | 否 | 否 | 生产者-消费者 |
StampedLock |
是 | 是 | 否 | 否 | 是 | 读写分离 |
常见问题解答（FAQ）
Q1：synchronized 和 ReentrantLock 有什么区别？
synchronized是内置锁，使用简单,但功能有限。ReentrantLock功能更丰富,但使用更复杂。
Q2：volatile 能保证原子性吗？
不能，volatile 只能保证可见性，不能保证原子性，如果需要原子操作，应该使用 Atomic 类。
Q3：什么时候用 BlockingQueue 而不是 synchronized？
当需要实现生产者-消费者模式时，BlockingQueue 更适合,因为它内置了线程阻塞和唤醒机制。
案例：银行账户转账
我们来看一个经典的转账案例,展示不同同步方法的应用：
// 使用 synchronized
public class Account {
private int balance;
public synchronized void transfer(Account target, int amount) {
if (balance < amount) {
throw new RuntimeException("余额不足");
}
balance -= amount;
target.balance += amount;
}
}
// 使用 ReentrantLock
public class Account {
private int balance;
private ReentrantLock lock = new ReentrantLock();
public void transfer(Account target, int amount) {
lock.lock();
try {
if (balance < amount) {
throw new RuntimeException("余额不足");
}
balance -= amount;
target.balance += amount;
} finally {
lock.unlock();
}
}
}
Java 中的同步方法多种多样，从最基础的 synchronized 到高级的 StampedLock，每种方法都有其适用的场景，选择哪种同步方法,需要根据实际需求来权衡：
- 如果只是简单的同步控制，
synchronized足够了。 - 如果需要更灵活的锁控制，
ReentrantLock是更好的选择。 - 如果只是状态标记，
volatile就可以。 - 如果需要原子操作，
Atomic类是首选。 - 如果是生产者-消费者模式，
BlockingQueue是最佳选择。
希望这篇文章能帮助你更好地理解 Java 中的同步方法，让你在多线程编程中更加得心应手！如果你有任何问题，欢迎在评论区留言讨论 😄
相关的知识点：
