通过示例讲解Java有哪些加锁方式
在Java中,加锁的方式主要有以下几种:
1. synchronized 关键字
synchronized 是Java中最基本的加锁机制,可以用于方法或代码块。
实例方法:
public synchronized void method() { // 同步代码 }锁的是当前实例对象。
静态方法:
public static synchronized void staticMethod() { // 同步代码 }锁的是当前类的
Class对象。代码块:
public void method() { synchronized (this) { // 同步代码 } }锁的是指定对象。
2. ReentrantLock
ReentrantLock 是 java.util.concurrent.locks 包中的类,提供了比 synchronized 更灵活的锁机制。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Example {
private final Lock lock = new ReentrantLock();
public void method() {
lock.lock(); // 加锁
try {
// 同步代码
} finally {
lock.unlock(); // 释放锁
}
}
}
3. ReadWriteLock
ReadWriteLock 是一种读写锁,允许多个读线程同时访问,但写线程独占锁。
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Example {
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
public void readMethod() {
rwLock.readLock().lock();
try {
// 读操作
} finally {
rwLock.readLock().unlock();
}
}
public void writeMethod() {
rwLock.writeLock().lock();
try {
// 写操作
} finally {
rwLock.writeLock().unlock();
}
}
}
4. StampedLock
StampedLock 是Java 8引入的锁机制,支持乐观读锁、悲观读锁和写锁。
import java.util.concurrent.locks.StampedLock;
public class Example {
private final StampedLock stampedLock = new StampedLock();
public void readMethod() {
long stamp = stampedLock.readLock();
try {
// 读操作
} finally {
stampedLock.unlockRead(stamp);
}
}
public void writeMethod() {
long stamp = stampedLock.writeLock();
try {
// 写操作
} finally {
stampedLock.unlockWrite(stamp);
}
}
public void optimisticReadMethod() {
long stamp = stampedLock.tryOptimisticRead();
// 读操作
if (!stampedLock.validate(stamp)) {
stamp = stampedLock.readLock();
try {
// 重新读操作
} finally {
stampedLock.unlockRead(stamp);
}
}
}
}
5. Semaphore
Semaphore 是一种计数信号量,用于控制同时访问特定资源的线程数量。
import java.util.concurrent.Semaphore;
public class Example {
private final Semaphore semaphore = new Semaphore(10); // 允许10个线程同时访问
public void method() throws InterruptedException {
semaphore.acquire(); // 获取许可
try {
// 同步代码
} finally {
semaphore.release(); // 释放许可
}
}
}
6. Condition
Condition 通常与 ReentrantLock 配合使用,用于线程间的协调。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Example {
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
public void awaitMethod() throws InterruptedException {
lock.lock();
try {
condition.await(); // 等待
} finally {
lock.unlock();
}
}
public void signalMethod() {
lock.lock();
try {
condition.signal(); // 唤醒
} finally {
lock.unlock();
}
}
}
7. Atomic 类
Atomic 类(如 AtomicInteger、AtomicReference 等)通过CAS(Compare-And-Swap)实现无锁同步。
import java.util.concurrent.atomic.AtomicInteger;
public class Example {
private final AtomicInteger atomicInteger = new AtomicInteger(0);
public void increment() {
atomicInteger.incrementAndGet(); // 原子操作
}
}
8. LockSupport
LockSupport 提供了线程阻塞和唤醒的基本操作。
import java.util.concurrent.locks.LockSupport;
public class Example {
public void parkMethod() {
LockSupport.park(); // 阻塞当前线程
}
public void unparkMethod(Thread thread) {
LockSupport.unpark(thread); // 唤醒指定线程
}
}
总结
synchronized:简单易用,适合大多数场景。ReentrantLock:提供更多功能,如可中断锁、超时锁等。ReadWriteLock:适合读多写少的场景。StampedLock:性能更高,适合复杂场景。Semaphore:控制资源访问数量。Condition:用于线程间协调。Atomic类:无锁同步,适合简单操作。LockSupport:底层线程阻塞和唤醒工具。
根据具体需求选择合适的加锁方式。
到此这篇关于Java有哪些加锁方式的文章就介绍到这了,更多相关Java加锁方式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!
相关文章
Java数据结构及算法实例:插入排序 Insertion Sort
这篇文章主要介绍了Java数据结构及算法实例:插入排序 Insertion Sort,本文直接给出实例代码,代码中包含详细注释,需要的朋友可以参考下2015-06-06
SpringData如何通过@Query注解支持JPA语句和原生SQL语句
这篇文章主要介绍了SpringData如何通过@Query注解支持JPA语句和原生SQL语句,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教2021-11-11
maven坐标Dependencies和Exclusions的使用
这篇文章主要介绍了maven坐标Dependencies和Exclusions的使用,很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教2021-12-12
Springbootadmin与security冲突问题及解决
这篇文章主要介绍了Springbootadmin与security冲突问题及解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-08-08


最新评论