Heim >Java >javaLernprogramm >Ausführliche Erklärung mit Bildern und Text! Zusammenfassung der Sperren in Java
Ausführliche Erklärung mit Bildern und Text! Zusammenfassung der Sperren in Java
- WBOYnach vorne
- 2022-04-15 18:16:272013Durchsuche
Dieser Artikel vermittelt Ihnen relevantes Wissen über Java und stellt hauptsächlich relevante Inhalte zu Sperren vor, einschließlich optimistischer Sperren, pessimistischer Sperren, exklusiver Sperren, gemeinsam genutzter Sperren usw. Ich hoffe, wir werden sie gemeinsam anschauen. Hilfreich für alle.
Empfohlenes Lernen: „Java-Video-Tutorial“
optimistische Sperre und pessimistische Sperre
pessimistische Sperre
pessimistische Sperre entspricht pessimistischen Menschen im Leben, Pessim istisch Die Leute denken immer, dass die Dinge in die falsche Richtung gehen. 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。
举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。
回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程也可能会操作这个数据，所以每次操作前都会上锁，这样其他线程想操作这个数据拿不到锁只能阻塞了。
在 Java 语言中 synchronized 和 ReentrantLock等就是典型的悲观锁，还有一些使用了 synchronized 关键字的容器类如 HashTable 等也是悲观锁的应用。
乐观锁
乐观锁 对应于生活中乐观的人，乐观的人总是想着事情往好的方向发展。
举个生活中的例子，假设厕所只有一个坑位了，乐观锁认为：这荒郊野外的，又没有什么人，不会有人抢我坑位的，每次关门上锁多浪费时间，还是不加锁好了。你看乐观锁就是天生乐观！
回到代码世界中，乐观锁操作数据时不会上锁，在更新的时候会判断一下在此期间是否有其他线程去更新这个数据。
乐观锁可以使用版本号机制和CAS算法实现。在 Java 语言中 java.util.concurrent.atomic包下的原子类就是使用CAS 乐观锁实现的。
两种锁的使用场景
悲观锁和乐观锁没有孰优孰劣，有其各自适应的场景。
乐观锁适用于写比较少（冲突比较小）的场景，因为不用上锁、释放锁，省去了锁的开销，从而提升了吞吐量。
如果是写多读少的场景，即冲突比较严重，线程间竞争激励，使用乐观锁就是导致线程不断进行重试，这样可能还降低了性能，这种场景下使用悲观锁就比较合适。
独占锁和共享锁
独占锁
独占锁是指锁一次只能被一个线程所持有。如果一个线程对数据加上排他锁后，那么其他线程不能再对该数据加任何类型的锁。获得独占锁的线程即能读数据又能修改数据。
JDK中的synchronized和java.util.concurrent(JUC)包中Lock的实现类就是独占锁。
共享锁
共享锁是指锁可被多个线程所持有。如果一个线程对数据加上共享锁后，那么其他线程只能对数据再加共享锁，不能加独占锁。获得共享锁的线程只能读数据，不能修改数据。
在 JDK 中 ReentrantReadWriteLock 就是一种共享锁。
互斥锁和读写锁
互斥锁
互斥锁是独占锁的一种常规实现，是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。
互斥锁一次只能一个线程拥有互斥锁，其他线程只有等待。
读写锁
读写锁
🎜🎜In der Java-Sprache sind synchronized und ReentrantLock typische pessimistische Sperren. Es gibt auch einige Containerklassen, die das synchronisierte Schlüsselwort verwenden, wie z. B. HashTableCode Code> usw. sind ebenfalls Anwendungen pessimistischer Sperren. 🎜🎜🎜Optimistic Lock🎜🎜🎜<code>Optimistic Lock entspricht optimistischen Menschen im Leben, die immer daran denken, dass die Dinge in eine gute Richtung gehen. 🎜🎜Um ein Beispiel im Leben zu nennen: Angenommen, es gibt nur eine Grube in der Toilette und denkt: Es gibt nicht viele Menschen in dieser Wildnis und niemand wird mir meine Grube schnappen. Es ist Zeitverschwendung. Es ist besser, es nicht zu verschließen. Sie sehen, optimistische Locken werden optimistisch geboren! 🎜🎜Zurück in der Codewelt wird beim Aktualisieren von Daten durch optimistisches Sperren nicht gesperrt, ob andere Threads die Daten in diesem Zeitraum aktualisieren. 🎜🎜🎜🎜Optimistisches Sperren kann mithilfe des Versionsnummernmechanismus und des CAS-Algorithmus implementiert werden. In der Java-Sprache wird die atomare Klasse im Paket java.util.concurrent.atomic mithilfe der optimistischen CAS-Sperre implementiert. 🎜🎜🎜Nutzungsszenarien der beiden Arten von Sperren🎜🎜🎜Pessimistische Sperre und optimistische Sperre sind nicht besser oder schlechter, sie haben ihre eigenen geeigneten Szenarien. 🎜🎜Optimistisches Sperren eignet sich für Szenarien mit relativ wenigen Schreibvorgängen (relativ kleine Konflikte). Da die Sperre nicht gesperrt oder freigegeben werden muss, entfällt der Sperraufwand, wodurch der Durchsatz verbessert wird. 🎜🎜Wenn es sich um ein Szenario mit mehr Schreibvorgängen und weniger Lesevorgängen handelt, d. Es ist angemessener, eine pessimistische Sperre zu verwenden. 🎜🎜Exklusive Sperre und gemeinsame Sperre🎜🎜🎜Exklusive Sperre🎜🎜🎜Exklusive Sperre bedeutet, dass die Sperre jeweils nur von einem Thread gehalten werden kann. Wenn ein Thread den Daten eine exklusive Sperre hinzufügt, können andere Threads den Daten keine Sperre mehr hinzufügen. Ein Thread, der eine exklusive Sperre erhält, kann Daten sowohl lesen als auch ändern. 🎜🎜🎜🎜Die Implementierungsklasse von Lock in den Paketen synchronized und java.util.concurrent(JUC) im JDK ist eine exklusive Sperre. 🎜🎜🎜Gemeinsame Sperre🎜🎜🎜Gemeinsame Sperre bedeutet, dass die Sperre von mehreren Threads gehalten werden kann. Wenn ein Thread den Daten eine gemeinsame Sperre hinzufügt, können andere Threads den Daten nur gemeinsame Sperren und keine exklusiven Sperren hinzufügen. Der Thread, der die gemeinsame Sperre erhält, kann nur Daten lesen und die Daten nicht ändern. 🎜🎜🎜🎜In JDK ist ReentrantReadWriteLock eine Art gemeinsame Sperre. 🎜🎜Mutex-Sperren und Lese-/Schreibsperren🎜🎜🎜Mutex-Sperren🎜🎜🎜Mutex-Sperre ist eine herkömmliche Implementierung einer exklusiven Sperre, was bedeutet, dass auf eine bestimmte Ressource jeweils nur ein Besucher zugreifen kann time Access ist einzigartig und exklusiv. 🎜🎜🎜🎜Mutex-Sperre Es kann jeweils nur ein Thread die Mutex-Sperre besitzen, und andere Threads können nur warten. 🎜🎜🎜Lese-/Schreibsperre🎜🎜🎜Lese-/Schreibsperre ist eine spezifische Implementierung einer gemeinsamen Sperre. Lese-/Schreibsperren verwalten eine Reihe von Sperren, eine davon ist eine schreibgeschützte Sperre und die andere ist eine Schreibsperre. 🎜Die Lesesperre kann von mehreren Threads gleichzeitig gehalten werden, wenn keine Schreibsperre vorhanden ist und die Schreibsperre exklusiv ist. Die Priorität einer Schreibsperre ist höher als die einer Lesesperre. Ein Thread, der eine Lesesperre erhält, muss den durch die zuvor freigegebene Schreibsperre aktualisierten Inhalt sehen können.
Lese-/Schreibsperren haben einen höheren Grad an Parallelität als Mutex-Sperren. Es gibt jeweils nur einen Schreibthread, aber mehrere Threads können gleichzeitig lesen.
definiert eine Lese-/Schreibsperrschnittstelle im JDK: ReadWriteLockReadWriteLock
public interface ReadWriteLock {
/**
* 获取读锁
*/
Lock readLock();
/**
* 获取写锁
*/
Lock writeLock();
}
ReentrantReadWriteLock 实现了ReadWriteLock接口，具体实现这里不展开，后续会深入源码解析。
公平锁和非公平锁
公平锁
公平锁是指多个线程按照申请锁的顺序来获取锁，这里类似排队买票，先来的人先买，后来的人在队尾排着，这是公平的。
在 java 中可以通过构造函数初始化公平锁
/** * 创建一个可重入锁，true 表示公平锁，false 表示非公平锁。默认非公平锁 */ Lock lock = new ReentrantLock(true);
非公平锁
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的状态（某个线程一直得不到锁）。
在 java 中 synchronized 关键字是非公平锁，ReentrantLock默认也是非公平锁。
/** * 创建一个可重入锁，true 表示公平锁，false 表示非公平锁。默认非公平锁 */ Lock lock = new ReentrantLock(false);
可重入锁
可重入锁又称之为递归锁，是指同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。
对于Java ReentrantLock而言, 他的名字就可以看出是一个可重入锁。对于Synchronized而言，也是一个可重入锁。
敲黑板：可重入锁的一个好处是可一定程度避免死锁。
以 synchronized 为例，看一下下面的代码：
public synchronized void mehtodA() throws Exception{
// Do some magic tings
mehtodB();
}
public synchronized void mehtodB() throws Exception{
// Do some magic tings
}
上面的代码中 methodA 调用 methodB，如果一个线程调用methodA 已经获取了锁再去调用 methodB 就不需要再次获取锁了，这就是可重入锁的特性。如果不是可重入锁的话，mehtodB 可能不会被当前线程执行，可能造成死锁。
自旋锁
自旋锁是指线程在没有获得锁时不是被直接挂起，而是执行一个忙循环，这个忙循环就是所谓的自旋。
自旋锁的目的是为了减少线程被挂起的几率，因为线程的挂起和唤醒也都是耗资源的操作。
如果锁被另一个线程占用的时间比较长，即使自旋了之后当前线程还是会被挂起，忙循环就会变成浪费系统资源的操作，反而降低了整体性能。因此自旋锁是不适应锁占用时间长的并发情况的。
在 Java 中，AtomicInteger 类有自旋的操作，我们看一下代码：
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
CAS 操作如果失败就会一直循环获取当前 value 值然后重试。
另外自适应自旋锁也需要了解一下。
在JDK1.6又引入了自适应自旋，这个就比较智能了，自旋时间不再固定，由前一次在同一个锁上的自旋时间以及锁的拥有者的状态来决定。如果虚拟机认为这次自旋也很有可能再次成功那就会次序较多的时间，如果自旋很少成功，那以后可能就直接省略掉自旋过程，避免浪费处理器资源。
分段锁
分段锁 是一种锁的设计，并不是具体的一种锁。
分段锁设计目的是将锁的粒度进一步细化，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。
在 Java 语言中 CurrentHashMap 底层就用了分段锁，使用Segment，就可以进行并发使用了。
锁升级（无锁|偏向锁|轻量级锁|重量级锁）
JDK1.6 为了提升性能减少获得锁和释放锁所带来的消耗，引入了4种锁的状态：无锁、偏向锁、轻量级锁和重量级锁，它会随着多线程的竞争情况逐渐升级，但不能降级。
无锁
无锁
private static final Object LOCK = new Object();
for(int i = 0;i <code>ReentrantReadWriteLock</code> implementiert die <code>ReadWriteLock</code>-Schnittstelle, spezifische Implementierung Wir haben gewonnen Wir gehen hier nicht weiter darauf ein, wir werden uns später mit der detaillierten Analyse des Quellcodes befassen. 🎜<h2>Fair Lock und Unfair Lock</h2>🎜<strong>Fair Lock</strong>🎜🎜<code>Fair Lock</code> bedeutet, dass mehrere Threads Sperren in der Reihenfolge erwerben, in der sie Sperren beantragen. hier Ähnlich wie beim Anstehen, um Tickets zu kaufen, kaufen diejenigen, die zuerst kommen, zuerst und diejenigen, die später kommen, stehen am Ende der Warteschlange an. Das ist fair. 🎜🎜<img alt="Ausführliche Erklärung mit Bildern und Text! Zusammenfassung der Sperren in Java" src="https://img.php.cn/upload/article/000/000/067/5cab904b73cc3c2ec71a08b113232b72-6.png">🎜🎜In Java können faire Sperren über den Konstruktor initialisiert werden🎜<pre class="brush:php;toolbar:false"> synchronized(LOCK){
for(int i = 0;i 🎜<strong>Unfair lock</strong>🎜🎜<code>Unfair lock</code> bedeutet, dass die Reihenfolge, in der mehrere Threads Sperren erwerben, nicht stimmt Abhängig von der Reihenfolge, in der Sperren beantragt werden, ist es möglich, dass der Thread, der später angewendet wurde, die Sperre vor dem Thread erhält, der zuerst angewendet wurde. In einer Umgebung mit hoher Parallelität kann dies zu einer Prioritätsumkehr oder einem Mangel führen (ein bestimmter Thread erhält die Sperre nie). ). 🎜🎜<img alt="Ausführliche Erklärung mit Bildern und Text! Zusammenfassung der Sperren in Java" src="https://img.php.cn/upload/article/000/000/067/5cab904b73cc3c2ec71a08b113232b72-7.png">🎜🎜In Java ist das synchronisierte Schlüsselwort eine unfaire Sperre, und ReentrantLock ist standardmäßig ebenfalls eine unfaire Sperre. 🎜<pre class="brush:php;toolbar:false">public String test(String s1, String s2){
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(s1);
stringBuffer.append(s2);
return stringBuffer.toString();
}Reentrant Lock
🎜Reentrant Lock wird auch rekursive Sperre genannt, was bedeutet, dass derselbe Thread die Sperre in der äußeren Methode, der Sperre, erhält wird bei Eingabe der inneren Methode automatisch erfasst. 🎜🎜🎜🎜Bei Java ReentrantLock lässt sich anhand des Namens erkennen, dass es sich um eine Wiedereintrittssperre handelt. Bei Synchronized handelt es sich auch um eine Wiedereintrittssperre. 🎜🎜Klopfen Sie an die Tafel: Ein Vorteil von Wiedereintrittssperren besteht darin, dass Deadlocks bis zu einem gewissen Grad vermieden werden können. 🎜🎜Nehmen Sie synchronisiert als Beispiel und sehen Sie sich den folgenden Code an: 🎜StringBuffer.class
// append 是同步方法
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}🎜Im obigen Code ruft MethodeA MethodeA auf und hat die Sperre erworben und ruft dann MethodeB auf . Dies sind Wiedereintrittseigenschaften. Wenn es sich nicht um eine Wiedereintrittssperre handelt, wird mehtodB möglicherweise nicht vom aktuellen Thread ausgeführt, was zu einem Deadlock führen kann. 🎜Spin lock
🎜Spin lock bedeutet, dass der Thread nicht direkt angehalten wird, wenn er die Sperre erhält, sondern eine Besetztschleife ausführt. sogenannte Selbstsperre. 🎜🎜🎜🎜Der Zweck der Spin-Sperre besteht darin, die Wahrscheinlichkeit zu verringern, dass der Thread angehalten wird, da das Anhalten und Aufwecken des Threads ebenfalls ressourcenintensive Vorgänge sind. 🎜🎜Wenn die Sperre längere Zeit von einem anderen Thread belegt ist, wird der aktuelle Thread auch nach dem Spinnen immer noch angehalten, und die Auslastungsschleife führt zu einer Verschwendung von Systemressourcen, was tatsächlich die Gesamtleistung verringert. Daher eignen sich Spin-Sperren nicht für Parallelitätssituationen, in denen die Sperre lange dauert. 🎜🎜In Java verfügt die Klasse AtomicInteger über eine Spin-Operation: 🎜rrreee🎜Wenn die CAS-Operation fehlschlägt, wird eine Schleife ausgeführt, um den aktuellen Wert abzurufen, und es dann erneut versucht . 🎜🎜Darüber hinaus müssen Sie auch über die adaptive Spin-Sperre Bescheid wissen. 🎜🎜Adaptive Spin wurde in JDK1.6 eingeführt, was intelligenter ist. Die Spin-Zeit ist nicht mehr festgelegt, sondern wird durch die vorherige Spin-Zeit für dasselbe Schloss und den Status des Schlossbesitzers bestimmt. Wenn die virtuelle Maschine davon ausgeht, dass dieser Spin wahrscheinlich erneut erfolgreich sein wird, dauert es länger. Wenn der Spin selten erfolgreich ist, kann er den Spin-Prozess in Zukunft direkt auslassen, um eine Verschwendung von Prozessorressourcen zu vermeiden. 🎜Segmentiertes Schloss
🎜Segmentiertes Schloss ist ein Schlossdesign, kein bestimmtes Schloss. 🎜🎜Der Entwurfszweck der segmentierten Sperre besteht darin, die Granularität der Sperre weiter zu verfeinern. Wenn für den Vorgang nicht das gesamte Array aktualisiert werden muss, kann nur ein Element im Array gesperrt werden. 🎜🎜🎜🎜In der Java-Sprache verwendet die zugrunde liegende Ebene von CurrentHashMap Segmentierungssperren und kann gleichzeitig verwendet werden. 🎜Sperren-Upgrade (keine Sperre|voreingenommene Sperre|leichte Sperre|schwere Sperre)
🎜JDK1.6 Um die Leistung zu verbessern und den durch den Erwerb und die Freigabe von Sperren verursachten Verbrauch zu reduzieren, werden 4 Arten von Sperren eingeführt :No lock, Biased lock, Lightweight lock und Heavyweight lock, es folgt eine Multithread-Race-Bedingung Eskaliert allmählich, kann aber nicht abgebaut werden. 🎜🎜Sperrfrei🎜🎜Sperrfrei Der Zustand ist eigentlich die oben erwähnte optimistische Sperre, die hier nicht beschrieben wird. 🎜偏向锁
Java偏向锁(Biased Locking)是指它会偏向于第一个访问锁的线程，如果在运行过程中，只有一个线程访问加锁的资源，不存在多线程竞争的情况，那么线程是不需要重复获取锁的，这种情况下，就会给线程加一个偏向锁。
偏向锁的实现是通过控制对象Mark Word的标志位来实现的，如果当前是可偏向状态，需要进一步判断对象头存储的线程 ID 是否与当前线程 ID 一致，如果一致直接进入。
轻量级锁
当线程竞争变得比较激烈时，偏向锁就会升级为轻量级锁，轻量级锁认为虽然竞争是存在的，但是理想情况下竞争的程度很低，通过自旋方式等待上一个线程释放锁。
重量级锁
如果线程并发进一步加剧，线程的自旋超过了一定次数，或者一个线程持有锁，一个线程在自旋，又来了第三个线程访问时（反正就是竞争继续加大了），轻量级锁就会膨胀为重量级锁，重量级锁会使除了此时拥有锁的线程以外的线程都阻塞。
升级到重量级锁其实就是互斥锁了，一个线程拿到锁，其余线程都会处于阻塞等待状态。
在 Java 中，synchronized 关键字内部实现原理就是锁升级的过程：无锁 --> 偏向锁 --> 轻量级锁 --> 重量级锁。这一过程在后续讲解 synchronized 关键字的原理时会详细介绍。
锁优化技术（锁粗化、锁消除）
锁粗化
锁粗化就是将多个同步块的数量减少，并将单个同步块的作用范围扩大，本质上就是将多次上锁、解锁的请求合并为一次同步请求。
举个例子，一个循环体中有一个代码同步块，每次循环都会执行加锁解锁操作。
private static final Object LOCK = new Object();
for(int i = 0;i <p>经过<code>锁粗化</code>后就变成下面这个样子了：</p><pre class="brush:php;toolbar:false"> synchronized(LOCK){
for(int i = 0;i <p><strong>锁消除</strong></p><p><code>锁消除</code>是指虚拟机编译器在运行时检测到了共享数据没有竞争的锁，从而将这些锁进行消除。</p><p>举个例子让大家更好理解。</p><pre class="brush:php;toolbar:false">public String test(String s1, String s2){
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(s1);
stringBuffer.append(s2);
return stringBuffer.toString();
}上面代码中有一个 test 方法，主要作用是将字符串 s1 和字符串 s2 串联起来。
test 方法中三个变量s1, s2, stringBuffer， 它们都是局部变量，局部变量是在栈上的，栈是线程私有的，所以就算有多个线程访问 test 方法也是线程安全的。
我们都知道 StringBuffer 是线程安全的类，append 方法是同步方法，但是 test 方法本来就是线程安全的，为了提升效率，虚拟机帮我们消除了这些同步锁，这个过程就被称为锁消除。
StringBuffer.class
// append 是同步方法
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}一张图总结：
Java 并发编程的知识非常多，同时也是 Java 面试的高频考点，面试官必问的，需要学习 Java 并发编程其他知识的小伙伴可以去下载『阿里师兄总结的Java知识笔记 总共 283 页，超级详细』。
前面讲了 Java 语言中各种各种的锁，最后再通过六个问题统一总结一下：
推荐学习：《java视频教程》
Das obige ist der detaillierte Inhalt vonAusführliche Erklärung mit Bildern und Text! Zusammenfassung der Sperren in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!