Java 中的锁居然有这么多！

其实Java的锁有很多种，主要有以下几类： 1 、乐观锁和悲观锁 乐观锁：基于对数据的乐观态度，假设数据在操作过程中不会被其他线程修改。
读取数据时没有锁，更新数据时仅检查数据是否被修改。
主要实现方式有CAS机制、版本号机制、时间戳机制等。
悲观锁：基于对数据的悲观态度，认为数据在操作过程中可能会被其他线程修改。
无论是读还是写操作，都会通过持有锁来保证数据的一致性。
关键的实现方法包括synchronized关键字和ReentrantLock。
2 、公平锁和非公平锁 公平锁：根据先到先得的原则，线程按照申请锁的顺序获取锁。
非公平锁：不遵循先到先得的原则，后面的线程可能会先获得锁。
ReentrantLock可以指定为公平锁，也可以指定为非公平锁，synchronized关键字默认为非公平锁。
3 、排它锁和共享锁 排它锁：允许一个线程排它地拥有同步、ReentrantLock等锁定资源。
共享锁：多个线程可以共享同一个锁资源，例如读写锁中的读锁。
4 、互斥锁和读写锁 互斥锁：与独占锁类似，允许一个线程独占锁资源。
读写锁：允许多个线程访问读锁，但只有一个线程持有写锁，结合了排他锁和共享锁的特点。
主要实现类是ReentrantReadWriteLock和ReadWriteLock。
5 .可重入锁通过在线程持有锁的同时每次获取和释放锁的次数相同来确保线程安全。
主要实现是ReentrantLock。
6 .自旋锁：我们使用自旋机制来尝试获取锁，同时避免线程切换的开销。
自旋锁是一种锁优化技术。
7 、段锁定是JDK1 .7 版本中的实现方式之一。
将锁拆分为多个段可以提高锁的并发性能。
这些锁类型及其实现在Java并发编程中发挥着重要作用，帮助开发人员更好地控制并发访问并保证数据一致性。

java中常见的几种锁有哪些

Java中常见的锁类型及其特点如下：公平锁和非公平锁。
公平锁按照线程申请锁的顺序分配资源。
先申请的线程先获得锁，从而避免线程长期阻塞。
未分配的锁并不严格按照申请的顺序进行分配，后申请的线程可能会先获取锁。
不正确的锁可能会导致优先级倒置或饥饿（例如，当较低优先级线程持有锁时，较高优先级线程会被阻塞），但由于它们减少了线程切换开销，因此通常性能更好。
Java中reentrantLock的默认实现是非公平锁，可以通过构造参数设置为公平锁。
排他锁和共享锁排他锁只允许一个线程同时持有，如synchronized或reentrantlock。
共享锁允许多个线程同时持有，适合读多写少的场景，比如ReadWriteLock中的读锁。
共享锁通过分离读写操作来提高并发性能，但写操作仍然需要排它锁。
互斥锁和读写锁 互斥锁是排他锁的具体实现，它确保线程对共享资源具有互斥的访问权限。
典型代表就是可重入锁。
通过共享锁机制实现读写锁优化读操作，例如可重入ReadWriteLock。
读锁可以被多个线程共享，写锁是独占的。
在读多写少的场景下，读写锁可以显着减少线程阻塞，提高吞吐量。
乐观锁和悲观锁 乐观锁和悲观锁是并发控制策略，而不是不同的锁类型。
悲观锁假设并发操作必然会导致数据冲突，因此直接加锁（如synchronized或reentrantLock）适合写操作频繁的场景。
乐观锁假设冲突概率较低，通过无锁编程（如CAS算法）来实现。
典型的应用是Java原子类（AtomicInteger等）。
乐观锁通过自旋重试减少线程阻塞，适合读操作密集的场景。
然而，当竞争激烈时，自旋可能会消耗 CPU 资源。
总结 Java锁机制通过几种类型满足各种并发需求： fair/fair锁平衡公平性和性能；独占/共享锁控制资源访问方式；互斥/读写锁细化锁粒度；乐观/悲观锁提供策略选择。
在实际开发中，适当的锁类型或需要选择一个组合。

5000字，24张图带你彻底理解Java中的21种锁

全场彻底还原，拒绝套路，点击一键领取8 7 7 0元优惠大礼包。
了解Java中的2 1 种锁，从序号锁名称应用开始 1 .CAS乐观锁 乐观锁是基于乐观思维的。
假设并发写入的概率较低，并且读取数据时不会阻塞数据。
写入数据时，判断值是否一致，一致则更新。
实施CAS操作。
2 .同步、向量悲观锁 Hashtable悲观锁是基于悲观思想，认为写多读少会导致每次读或写数据时锁都会加锁。
其他线程必须等待锁被释放。
3 . 自旋锁 CAS 自旋锁使用线程在繁忙循环中托管死锁。
适合多核处理器，减少线程切换开销。
4 . ReentrantLock，可重入同步锁允许线程重新获取它而不会阻塞。
通过组合自定义同步器来实现。
5 .读写锁ReentrantReadWriteLock、CopyOnWriteArrayList、CopyOnWriteArraySet读写锁实现读写分离。
读不阻塞读，写阻塞写，提高效率。
6 .公平锁 ReentrantLock(true) 公平锁按照线程申请的顺序分配头发，保证公平。
7 .同步非公平锁、重入(false) 非公平锁不能保证公平性，但具有较高的性能，并且会导致线程饥饿。
8 .共享锁ReentrantReadWriteLock 共享锁读锁允许多个读操作，提高并发性能。
9 、同步排它锁、向量、哈希表、排它锁ReentrantReadWriteLock只允许一个线程运行，提高安全性。
1 0、同步重量级锁 重量级锁依赖操作系统互斥体，切换成本较高。
1 1 .轻量级锁 ReentrantReadWriteLock 轻量级锁在无竞争时通过CAS避免互斥开销。
1 2 .单向锁ReentrantReadWriteLock 单向锁消除了同步，提高了性能并减少了CAS操作。
1 3 、ConcurrentHashMap ConcurrentHashMap分段锁处理死锁，减少争用，提高并发性。
1 4 . 互斥锁 同步互斥锁确保资源被单个线程访问。
1 5 、Synchronized Synchronized Lock控制并发访问，保证数据一致性。
1 6 、死锁 当两个或多个线程互相等待对方释放资源，导致无限等待时，就会发生死锁。
1 7 . 块加厚 块加厚结合了多个操作来减少块开销。
1 8 、消除死锁：通过逃逸分析，判断数据不会被线程访问，消除死锁。
1 9 .synchronized关键字synchronized提供锁定功能并检查并发性。
2 0.Lock接口和synchronizedLock接口提供更灵活的锁控制。
Synchronized 语法简单，安全性有限。
2 1 、ReentrantLock和Synchronized ReentrantLock提供了更多的控制选项，比如正确性和性能优化。
学习这些锁的概念和应用可以帮助您更高效地管理和控制并发操作，避免性能瓶颈。

面试官问：Java 中的锁有哪些？我跪了……

Java中的锁有很多种，按照不同的分类标准，如下： 公平锁和非公平锁 公平锁：多个线程按照申请锁的顺序获取锁，按照先来先得的原则。
非公平锁：线程获取锁的顺序与申请的顺序不符。
后来申请的线程可能会先获得锁，这可能会导致优先级反转或饥饿。
Java中，ReentrantLock可以通过构造函数判断锁是否公平，默认是公平的；同步是非公平锁，无法改为公平锁。
非公平锁的优点是吞吐量比公平锁大。
重入锁也称为递归锁。
同一个线程在外层方法中获得锁后，进入内层方法时会自动获取锁。
Java中的ReentrantLock和Synchronized都是可重入锁，可以在一定程度上避免死锁。
比如代码中，如果没有重入锁，setB可能不会被当前线程执行，造成死锁。
排他锁和共享锁 排他锁：一次只能由一个线程持有。
Java中的ReentrantLock和Synchronized都是独占锁。
组合锁：可由多条锁链锁住。
在ReadWriteLock锁实现类中，读锁是共享锁，写锁是排它锁。
共享读锁可以保证高效的并发读，并且读写操作、写操作和读操作、写操作和写操作是互斥的，通过AQS来实现。
互斥锁和读写锁 互斥锁和读写锁是排它锁和共享锁的具体应用。
Java中互斥锁的具体实现是ReentrantLock； Java中读写锁的具体实现是ReadWriteLock。
乐观锁和悲观锁 悲观锁：认为对同一个数据的并发操作肯定会被修改，而采用加锁，适合写操作较多的场景。
Java中使用不同的锁来实现悲观锁。
乐观锁：认为对同一数据的并发操作不会被修改。
更新数据时，采用不断尝试更新、重试的方法。
适用于读操作较多的场景。
非锁定可以提高性能。
在爪哇，在无锁编程中，经常使用CAS算法来实现乐观锁。
例如，原子类通过CAS自旋实现原子操作更新。
分体锁是一种锁设计，而不是特定的锁。
以ConcurrentHashMap为例，它的并发实现是基于段锁格式的，内部有一个段，类似于HashMap的结构，并且它也继承了ReentrantLock。
放置物品时，首先通过哈希码选择剪辑，然后锁定剪辑。
多线程模式只要不在同一个段就可以并行；计算交易量时，必须获得所有扇区锁。
设计的目的是提高锁定精度，在操作不更新整个数组的情况下，只锁定数组的一个元素。
偏置锁、轻型锁和重型锁。
这三个锁用于同步锁状态，由对象屏幕的对象头中的字段指示。
偏向锁：一段并发代码总是由一个线程访问，线程自动获取锁，降低了获取锁的成本。
轻量级锁：当锁是偏向的，被其他线程访问时，偏向锁升级为轻量级锁，其他线程尝试通过自旋而不阻塞的方式获取锁，从而提高性能。
重量级锁：轻量级锁时，如果线程自旋一定次数但未能获取锁，就会进入阻塞。
该锁会膨胀成重量级锁，导致其他应用程序线程进入阻塞，性能恶化。
自旋锁 尝试获取锁的线程不会立即被阻塞。
相反，它会在循环中尝试获取锁，这减少了线程上下文切换的消耗，但循环会消耗CPU。