帮人做网站 怎么收费,江西建筑人才网,wordpress修改底部联系QQ,wordpress主题投稿简介
1、从Java5开始#xff0c;Java提供了一种功能更强大的线程同步机制——通过显式定义同步锁对象来实现同步#xff0c;在这种机制下#xff0c;同步锁由Lock对象充当。
2、Lock 提供了比synchronized方法和synchronized代码块更广泛的锁定操作#xff0c;Lock允许实…简介
1、从Java5开始Java提供了一种功能更强大的线程同步机制——通过显式定义同步锁对象来实现同步在这种机制下同步锁由Lock对象充当。
2、Lock 提供了比synchronized方法和synchronized代码块更广泛的锁定操作Lock允许实现更灵活的结构可以具有差别很大的属性并且支持多个相关的Condition对象。
3、Lock是控制多个线程对共享资源进行访问的工具。通常锁提供了对共享资源的独占访问每次只能有一个线程对Lock对象加锁线程开始访问共享资源之前应先获得Lock对象。
4、某些锁可能允许对共享资源并发访问如ReadWriteLock读写锁Lock、ReadWriteLock是Java5提供的两个根接口并为Lock 提供了ReentrantLock可重入锁实现类为ReadWriteLock提供了ReentrantReadWriteLock 实现类。
5、Java8新增了新型的StampedLock类在大多数场景中它可以替代传统的ReentrantReadWriteLock。ReentrantReadWriteLock 为读写操作提供了三种锁模式Writing、ReadingOptimistic、Reading。
ReentrantLock
什么是ReentrantLock
ReentrantLock 是 Java 中的一种锁实现它提供了与传统的 synchronized 关键字相似的功能但具有更多的灵活性和控制能力。
ReentrantLock特性
可重入性 与 synchronized 一样ReentrantLock 具有可重入性这意味着线程可以多次获取同一个锁而不会出现死锁。
锁的公平性 ReentrantLock 支持公平锁和非公平锁。在公平锁模式下锁将按照线程请求的顺序分配。在非公平锁模式下锁将在可用时立即分配给等待线程。
Condition 对象 ReentrantLock 提供了 Condition 对象它允许线程在特定条件下等待和通知其他线程。这对于线程间的协作非常有用。
中断响应 ReentrantLock 支持中断响应这意味着线程可以在等待锁的过程中响应中断信号。
超时锁定 ReentrantLock 允许您尝试获取锁并设置一个超时时间。如果在超时时间内无法获取锁线程可以执行其他操作。
lock 锁和synchronized 对比
可重入性 ReentrantLock 具有可重入性允许同一线程多次获取同一个锁而不会引发死锁。 synchronized 也是可重入的同一线程可以多次获得同一个锁。 灵活性 ReentrantLock 提供了更多的灵活性和控制允许你选择公平性和非公平性、设置超时、使用读写锁等高级功能。 synchronized 相对较简单提供的功能较少不支持超时、读写锁等高级功能。 条件等待 ReentrantLock 提供了 Condition 对象允许线程在特定条件下等待然后在条件满足时重新获取锁。 synchronized 缺少这种直接的条件等待机制但可以使用 wait() 和 notify() 方法实现类似的功能。 公平性 ReentrantLock 允许你选择锁的公平性以公平或非公平方式分配锁。在公平模式下锁将按照等待顺序分配给等待的线程。 synchronized 使用的是非公平锁不保证按等待顺序分配。 性能 synchronized 在某些情况下可能比 ReentrantLock 更高效因为它是 JVM 内置的一种机制。 ReentrantLock 在高竞争情况下可以提供更好的性能但它的创建和维护成本通常更高。 异常处理 ReentrantLock 具有灵活的异常处理机制可以捕获并处理锁操作中的异常。 synchronized 的异常处理相对较简单一旦发生异常锁将自动释放。 可中断性 ReentrantLock 允许线程响应中断可以在等待锁时中断线程。 synchronized 不支持线程中断。 锁的可绑定性 ReentrantLock 允许将锁绑定到多个条件。 synchronized 不提供类似的绑定条件的机制。
使用案例
在这个示例中我们创建了一个ReentrantLock实例并使用它来保护SharedResource对象中的doWork方法。两个线程“Thread 1和Thread 2”共享SharedResource对象并分别调用doWork方法。lock.lock()获取锁lock.unlock()释放锁确保在同一时刻只有一个线程可以进入doWork方法的同步块。这确保了线程之间的安全性和同步执行。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class LockExample {public static void main(String[] args) {// 创建一个ReentrantLock实例Lock lock new ReentrantLock();// 创建一个共享资源SharedResource resource new SharedResource(lock);// 创建多个线程并启动Thread thread1 new Thread(new Worker(resource), Thread 1);Thread thread2 new Thread(new Worker(resource), Thread 2);thread1.start();thread2.start();}
}class SharedResource {private Lock lock;public SharedResource(Lock lock) {this.lock lock;}public void doWork() {lock.lock(); // 获取锁try {// 同步的代码块for (int i 1; i 5; i) {System.out.println(Thread.currentThread().getName() is working: i);}} finally {lock.unlock(); // 释放锁}}
}class Worker implements Runnable {private SharedResource resource;public Worker(SharedResource resource) {this.resource resource;}Overridepublic void run() {resource.doWork();}
}
AQS回顾
AQS即AbstractQueuedSynchronizer的缩写这个是个内部实现了两个队列的抽象类分别是同步队列和条件队列。其中同步队列是一个双向链表里面储存的是处于等待状态的线程正在排队等待唤醒去获取锁而条件队列是一个单向链表里面储存的也是处于等待状态的线程只不过这些线程唤醒的结果是加入到了同步队列的队尾AQS所做的就是管理这两个队列里面线程之间的等待状态-唤醒的工作。 在同步队列中还存在2中模式分别是独占模式和共享模式这两种模式的区别就在于AQS在唤醒线程节点的时候是不是传递唤醒这两种模式分别对应独占锁和共享锁。 AQS是一个抽象类所以不能直接实例化当我们需要实现一个自定义锁的时候可以去继承AQS然后重写获取锁的方式和释放锁的方式还有管理state而ReentrantLock就是通过重写了AQS的tryAcquire和tryRelease方法实现的lock和unlock。 详情可以参考 https://juejin.cn/post/7006895386103119908
ReentrantLock实现原理 ReentrantLock结构 ReentrantLock实现Lock接口 有三个内部类 分别是 Sync、NonfairSync、FairSync其中Sync内部类继承自AQS承接了AQS的功能NonfairSync代表非公平锁、FairSync 代表公平锁 他们都是继承了Sync类通过Sync重写的方法tryAcquire、tryRelease可以知道ReentrantLock实现的是AQS的独占模式也就是独占锁这个锁是悲观锁。
非公平锁实现原理
获取锁 ReentrantLock有两个构造方法无参构造方法默认是创建非公平锁fair传false 也是非公平锁 默认非公平锁 所以子类NonfairSync 实现父类的抽象方法执行 lock 1.先用case 尝试去更新state的值 如果能更新成功就表示可以抢占到锁 把state更新成1 并设置线程信息执行结束 如果更新失败即此时state不等于0代表此时锁被其他线程占据着则执行acquire方法 2.nonfairTryAcquire 首先会获取state的值 判断state是否等于0 如果此时等于0 则代表有线程释放锁了并且把state改回了0 如果此时state 等于0 就再次尝试用cas 去将state的值由0变更成1 如果变更成功就代表抢占到了锁 然后设置一下线程信息这里就体现了非公平锁的特性 不会在意阻塞队列中是否有等待的线程然后结束 如果此时state不等于0 或者 cas 更新 state值失败则代表有线程占据着锁 此时会去判断当前线程是否是获得锁的线程 如果是获得锁的线程则代表是重入的则将state进行1 然后执行结束 3.如果这个当前线程不是获得锁的线程则会构建一个Node节点 然后由尾部放到阻塞队列中 park住 public ReentrantLock() {sync new NonfairSync();}/*** Creates an instance of {code ReentrantLock} with the* given fairness policy.** param fair {code true} if this lock should use a fair ordering policy*/public ReentrantLock(boolean fair) {sync fair ? new FairSync() : new NonfairSync();}final void lock() {//cas 原子操作修改state 的值 如果能修改成功则把0变成1 然后记录当前线程idif (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());else//抢占锁逻辑acquire(1);}public final void acquire(int arg) {//尝试获取独占锁 if (!tryAcquire(arg) //如果失败则假如aqs 队列中acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}final boolean nonfairTryAcquire(int acquires) {//获取当前线程final Thread current Thread.currentThread();、//拿到 State 值 int c getState();//如果是0 表示可以去获得锁if (c 0) {//cas 原子操作修改state 的值 如果能修改成功则把0变成1 然后记录当前线程idif (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}//如果当前线程就是获得锁的线程else if (current getExclusiveOwnerThread()) {//增加重入次数int nextc c acquires;if (nextc 0) // overflowthrow new Error(Maximum lock count exceeded);setState(nextc);return true;}return false;}private Node addWaiter(Node mode) {//构建一个nodeNode node new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failure// tail 尾节点 默认是nullNode pred tail;if (pred ! null) {//如果尾节点不等于空 把当前节点当成尾节点 然后把prev指针指向上一个节点 把新进来的节点改成尾节点node.prev pred;if (compareAndSetTail(pred, node)) {//把上一个节点的next 指针指向刚进来的节点pred.next node;return node;}}enq(node);return node;}private Node enq(final Node node) {for (;;) {Node t tail;if (t null) { // Must initialize//如果尾节点 null 用cas 构建一个节点 if (compareAndSetHead(new Node()))//把头节点赋值给尾节点tail head;} else {//如果尾节点不等于空 把当前节点当成尾节点 然后把prev指针指向上一个节点 把新进来的节点改成尾节点node.prev t;if (compareAndSetTail(t, node)) {//把上一个节点的next 指针指向刚进来的节点t.next node;return t;}}}}final boolean acquireQueued(final Node node, int arg) {boolean failed true;try {boolean interrupted false;for (;;) {//获取当前节点的前一个节点final Node p node.predecessor();//如果当前节点的前一个结点是头节点 则说明有资格去争夺锁if (p head tryAcquire(arg)) {//把当前节点设置成头节点setHead(node);p.next null; // help GCfailed false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) parkAndCheckInterrupt())interrupted true;}} finally {if (failed)cancelAcquire(node);}}// 当获取(资源)失败后检查并且更新结点状态
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {// 获取前驱结点的状态int ws pred.waitStatus;if (ws Node.SIGNAL) // 状态为SIGNAL为-1// 可以进行park操作return true; if (ws 0) { // 表示状态为CANCELLED为1do {node.prev pred pred.prev;} while (pred.waitStatus 0); // 找到pred结点前面最近的一个状态不为CANCELLED的结点// 赋值pred结点的next域pred.next node; } else { // 为PROPAGATE -3 或者是0 表示无状态,(为CONDITION -2时表示此节点在condition queue中) // 比较并设置前驱结点的状态为SIGNALcompareAndSetWaitStatus(pred, ws, Node.SIGNAL); }// 不能进行park操作return false;
}private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}释放锁 1.判断当前线程是不是锁的所有者如果是则进行步骤2如果不是则抛出异常。 2.判断此次释放锁后state的值是否为0如果是则代表锁有没有重入然后将锁的所有者设置成null且返回true然后执行步骤3如果不是则代表锁发生了重入执行步骤4。 3.现在锁已经释放完即state0唤醒同步队列中的后继节点进行锁的获取。 4.锁还没有释放完即state!0不唤醒同步队列。 public void unlock() {sync.release(1);}public final boolean release(int arg) {//释放锁成功if (tryRelease(arg)) {Node h head;//如果头节点不为空 并且状态不为0 if (h ! null h.waitStatus ! 0)//唤醒unparkSuccessor(h);return true;}return false;}protected final boolean tryRelease(int releases) {//state -1int c getState() - releases;if (Thread.currentThread() ! getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free false;if (c 0) {//如果c 0 表示当前是无锁状态 把线程iq清空free true;setExclusiveOwnerThread(null);}//重新设置 statesetState(c);return free;}private void unparkSuccessor(Node node) {/** If status is negative (i.e., possibly needing signal) try* to clear in anticipation of signalling. It is OK if this* fails or if status is changed by waiting thread.*/int ws node.waitStatus;if (ws 0)//设置head节点的状态为0 compareAndSetWaitStatus(node, ws, 0);/** Thread to unpark is held in successor, which is normally* just the next node. But if cancelled or apparently null,* traverse backwards from tail to find the actual* non-cancelled successor.*///拿到head节点的下一个节点Node s node.next;//如果下一个节点为null 或者 status0则表示是 CANCELLED 状态//听过尾部节点开始扫描 找到距离 head最近的一个 waitStatus0的节点if (s null || s.waitStatus 0) {s null;for (Node t tail; t ! null t ! node; t t.prev)if (t.waitStatus 0)s t;}//如果next 节点不等于空直接唤醒这个线程if (s ! null)LockSupport.unpark(s.thread);}公平锁实现原理 1.获取状态的state的值如果state0即代表锁没有被其它线程占用(但是并不代表同步队列没有线程在等待)执行步骤2。如果state!0则代表锁正在被其它线程占用执行步骤3。 2.判断同步队列是否存在线程(节点)如果不存在则直接将锁的所有者设置成当前线程且更新状态state然后返回true。 3.判断锁的所有者是不是当前线程如果是则更新状态state的值然后返回true如果不是那么返回false即线程会被加入到同步队列中
final void lock() {acquire(1);
}public final void acquire(int arg) {//同步队列中有线程 且 锁的所有者不是当前线程那么将线程加入到同步队列的尾部//保证了公平性也就是先来的线程先获得锁后来的不能抢先获取。if (!tryAcquire(arg) acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();
}protected final boolean tryAcquire(int acquires) {final Thread current Thread.currentThread();int c getState();//判断状态state是否等于0等于0代表锁没有被占用不等于0则代表锁被占用着。if (c 0) {//调用hasQueuedPredecessors方法判断同步队列中是否有线程在等待如果同步队列中没有//线程在等待 则当前线程成为锁的所有者如果同步队列中有线程在等待则继续往下执行//这个机制就是公平锁的机制也就是先让先来的线程获取锁后来的不能抢先获取。if (!hasQueuedPredecessors() compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}//判断当前线程是否为锁的所有者如果是那么直接更新状态state然后返回true。else if (current getExclusiveOwnerThread()) {int nextc c acquires;if (nextc 0)throw new Error(Maximum lock count exceeded);setState(nextc);return true;}//如果同步队列中有线程存在 且 锁的所有者不是当前线程则返回false。return false;
}
