- Java加锁有哪几种锁?synchronized,偏向锁
- 简单说说lock
- 项目中哪个地方用了countdownlanch,怎么使用?
认为自己在使用数据的时候一定有别的线程来修改数据,因此在获取数据的时候会先加锁,确保数据不会被别的线程修改。
synchronized 关键字和 Lock 的实现类都是悲观锁
适合写操作多的场景,先加锁可以保证写操作时数据正确。
显式的锁定之后再操作同步资源
2.2、伪代码说明 //============= 悲观锁的调用方式
public synchronized void m1(){
// 加锁后的业务逻辑 ......
}
// 保证多个线程使用的是同一个 lock 对象的前提下
ReentrantLock lock = new ReentrantLock();
public void m2(){
lock.lock();
try {
// 操作同步资源
} finally {
lock.unlock();
}
}
//============= 乐观锁的调用方式
//保证多个线程使用的是同一个AtomicInteger
private AtomicInteger atomicInteger = new AtomicInteger();
atomicInteger.incrementAndGet();
2.3、乐观锁
乐观锁认为自己在使用数据时 不会有别的线程修改数据 ,所以不会添加锁,只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。
如果这个数据没有被更新,当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新,则根据不同的实现方式执行不同的操作
乐观锁在 Java 中是通过使用无锁编程来实现, 最常采用的是 CAS 算法, Java 原子类中的递增操作就通过 CAS 自旋实现的。
适合读操作多的场景,不加锁的特点能够使其读操作的性能大幅提升。
乐观锁则直接去操作同步资源,是一种无锁算法,得之我幸不得我命,再抢
乐观锁一般有两种实现方式:
- 采用版本号机制
- CAS(Compare-and-Swap,即比较并替换)算法实现
锁相关的8种案例演示
看看JVM中对应的锁在哪里?
3.2、synchronized有三种应用方式
JDK源码(notify方法)说明举例
8种锁的案例实际体现在3个地方
(表格多了一种)
| Synchronized | |||
| 对象锁(实例锁) | 类锁(全局锁) | ||
| synchronized method(){} | synchronized(this){} | static synchronized method(){} | synchronized(class){} |
| 在同个实例对象内,所属线程独占对象锁,其他线程阻塞;不同的实例对象内无影响。 | 在同个类内,所属线程独占类锁,其他线程阻塞。 | ||
- 作用于实例方法,当前实例加锁,进入同步代码前要获得当前实例的锁;
- 作用于代码块,对括号里配置的对象加锁。
- 作用于静态方法,当前类加锁,进去同步代码前要获得当前类对象的锁;
-c 对代码进行反汇编
假如你需要更多信息
javap -v ***.class文件反编译
-v -verbose 输出附加信息(包括行号、本地变量表,反汇编等详细信息)
3.3.2、synchronized同步代码块javap -c ***.class文件反编译
反编译
synchronized同步代码块
实现使用的是monitorenter和monitorexit指令
一定是一个enter两个exit吗?
m1方法里面自己添加一个异常试试
3.3.3、synchronized普通同步方法javap -v ***.class文件反编译
反编译
synchronized普通同步方法
调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置。
如果设置了,执行线程会将先持有monitor然后再执行方法,
最后在方法完成(无论是正常完成还是非正常完成)时释放 monitor
3.3.4、synchronized静态同步方法javap -v ***.class文件反编译
反编译
synchronized静态同步方法
ACC_STATIC, ACC_SYNCHRONIZED访问标志区分该方法是否静态同步方法
3.4、反编译synchronized锁的是什么 3.4.1、面试题什么是管程monitor?
synchronized实现原理,monitor对象什么时候生成的?知道monitor的monitorenter和monitorexit这两个是怎么保证同步的吗,或者说,这两个操作计算机底层是如何执行的
3.4.2、管程管程 (英语:Monitors,也称为监视器) 是一种程序结构,结构内的多个子程序(对象或模块)形成的多个工作线程互斥访问共享资源。
这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。(把信号量及其操作原语“封装”在一个对象内部)管程实现了在一个时间点,最多只有一个线程在执行管程的某个子程序。管程提供了一种机制,管程可以看做一个软件模块,它是将共享的变量和对于这些共享变量的操作封装起来,形成一个具有一定接口的功能模块,进程可以调用管程来实现进程级别的并发控制。
在HotSpot虚拟机中,monitor采用ObjectMonitor实现
上述C++源码解读
ObjectMonitor.java→ObjectMonitor.cpp→objectMonitor.hpp
objectMonitor.hpp
ObjectMonitor中有几个关键属性
| _owner | 指向持有ObjectMonitor对象的线程 |
| _WaitSet | 存放处于wait状态的线程队列 |
| _EntryList | 存放处于等待锁block状态的线程队列 |
| _recursions | 锁的重入次数 |
| _count | 用来记录该线程获取锁的次数 |
每个对象天生都带着一个对象监视器
synchronized 必须作用于某个对象中,所以 Java 在对象的 头文件 存储了 锁的 相关信息。锁升级功能主要依赖于 MarkWord 中的锁标志位和释放偏向锁标志位,后续讲解锁升级时候我们再加深
4、公平锁和非公平锁 4.1、从ReentrantLock卖票编码演示公平和非公平现象package com.atguigu.juc.locks;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Ticket
{
private int number = 50;
private Lock lock = new ReentrantLock(true); //默认用的是非公平锁,分配的平均一点,=--》公平一点
public void sale()
{
lock.lock();
try
{
if(number > 0)
{
System.out.println(Thread.currentThread().getName()+"t 卖出第: "+(number--)+"t 还剩下: "+number);
}
}finally {
lock.unlock();
}
}
}
public class SaleTicketDemo
{
public static void main(String[] args)
{
Ticket ticket = new Ticket();
new Thread(() -> { for (int i = 1; i <=55; i++) ticket.sale(); },"a").start();
new Thread(() -> { for (int i = 1; i <=55; i++) ticket.sale(); },"b").start();
new Thread(() -> { for (int i = 1; i <=55; i++) ticket.sale(); },"c").start();
new Thread(() -> { for (int i = 1; i <=55; i++) ticket.sale(); },"d").start();
new Thread(() -> { for (int i = 1; i <=55; i++) ticket.sale(); },"e").start();
}
}
4.2、何为公平锁/非公平锁?
⽣活中,排队讲求先来后到视为公平。程序中的公平性也是符合请求锁的绝对时间的,其实就是 FIFO,否则视为不公平
4.2.1、源码解读:按序排队公平锁,就是判断同步队列是否还有先驱节点的存在(我前面还有人吗?),如果没有先驱节点才能获取锁;
先占先得非公平锁,是不管这个事的,只要能抢获到同步状态就可以
4.2.2、面试题为什么会有公平锁/非公平锁的设计为什么默认非公平?
1、恢复挂起的线程到真正锁的获取还是有时间差的,从开发人员来看这个时间微乎其微,但是从CPU的角度来看,这个时间差存在的还是很明显的。所以非公平锁能更充分的利用CPU 的时间片,尽量减少 CPU 空闲状态时间。
2、使用多线程很重要的考量点是线程切换的开销,当采用非公平锁时, 当1个线程请求锁获取同步状态,然后释放同步状态,因为不需要考虑是否还有前驱节点,所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大,所以就减少了线程的开销 。
使⽤公平锁会有什么问题
公平锁保证了排队的公平性,非公平锁霸气的忽视这个规则,所以就有可能导致排队的长时间在排队,也没有机会获取到锁,
这就是传说中的 “锁饥饿”
什么时候用公平?什么时候用非公平?
如果为了更高的吞吐量,很显然非公平锁是比较合适的,因为节省很多线程切换时间,吞吐量自然就上去了;
否则那就用公平锁,大家公平使用。
5、可重入锁(又名递归锁) 5.1、说明可重入锁又名递归锁
是指在同一个线程在外层方法获取锁的时候,再进入该线程的内层方法会自动获取锁(前提,锁对象得是同一个对象),不会因为之前已经获取过还没释放而阻塞。
如果是1个有 synchronized 修饰的递归调用方法, 程序第2次进入被自己阻塞了岂不是天大的笑话,出现了作茧自缚。
所以 Java中ReentrantLock和synchronized都是可重入锁 ,可重入锁的一个优点是可一定程度避免死锁。
“可重入锁”这四个字分开来解释:
可:可以。
重:再次。
入:进入。
锁:同步锁。
进入什么?进入同步域(即同步代码块/方法或显式锁锁定的代码)
一句话
一个线程中的多个流程可以获取同一把锁,持有这把同步锁可以再次进入。
自己可以获取自己的内部锁
5.2、可重入锁种类隐式锁(即synchronized关键字使用的锁)默认是可重入锁
指的是可重复可递归调用的锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁,这样的锁就叫做可重入锁。
简单的来说就是: 在一个synchronized修饰的方法或代码块的内部调用本类的其他synchronized修饰的方法或代码块时,是永远可以得到锁的
与可重入锁相反,不可重入锁不可递归调用,递归调用就发生死锁。
同步块
static Object objectLock = new Object();
public static void syncBlock()
{
new Thread(() -> {
synchronized (objectLock) {// lock
System.out.println("-----外层");
synchronized (objectLock)
{
System.out.println("-----中层");
synchronized (objectLock)
{
System.out.println("-----内层");
}
}
}//unlock
},"t1").start();
}
同步方法
public class ReEntryLockDemoCopy {
public synchronized void m1() {
System.out.println("-----m1");
m2();
}
public synchronized void m2() {
System.out.println("-----m2");
m3();
}
public synchronized void m3() {
System.out.println("-----m3");
}
public static void main(String[] args) {
ReEntryLockDemoCopy reEntryLockDemo = new ReEntryLockDemoCopy();
reEntryLockDemo.m1();
}
}
Synchronized的重入的实现机理
每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。
当执行monitorenter时,如果目标锁对象的计数器为零,那么说明它没有被其他线程所持有,Java虚拟机会将该锁对象的持有线程设置为当前线程,并且将其计数器加1。
在目标锁对象的计数器不为零的情况下,如果锁对象的持有线程是当前线程,那么 Java 虚拟机可以将其计数器加1,否则需要等待,直至持有线程释放该锁。
当执行monitorexit时,Java虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放。
为什么任何一个对象都可以成为一个锁???
显式锁(即Lock)也有ReentrantLock这样的可重入锁。
package com.atguigu.juc.locks;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReEntryLockDemo
{
public static void main(String[] args)
{
Lock lock = new ReentrantLock();
new Thread(() -> {
lock.lock();
try
{
System.out.println(Thread.currentThread().getName()+"t"+"-----外层");
lock.lock();
try
{
System.out.println(Thread.currentThread().getName()+"t"+"-----内层");
}finally {
// 这里故意注释,实现加锁次数和释放次数不一样
// 由于加锁次数和释放次数不一样,第二个线程始终无法获取到锁,导致一直在等待。
// lock.unlock(); // 正常情况,加锁几次就要解锁几次
}
}finally {
lock.unlock();
}
},"t1").start();
new Thread(() -> {
lock.lock();
try
{
System.out.println("------22222");
}finally {
lock.unlock();
}
},"t2").start();
}
}
5.3、死锁及排查
5.3.1、是什么
死锁是指两个或两个以上的线程在执行过程中 , 因争夺资源而造成的一种 互相等待的现象 , 若无外力干涉那它们都将无法推进下去,如果系统资源充足,进程的资源请求都能够得到满足,死锁出现的可能性就很低,否则就会因争夺有限的资源而陷入死锁。
产生死锁主要原因:
- 系统资源不足
- 进程运行推进的顺序不合适
- 资源分配不当
package com.atguigu.juc.locks;
import java.util.concurrent.TimeUnit;
public class DeadLockDemo
{
static Object lockA = new Object();
static Object lockB = new Object();
public static void main(String[] args)
{
Thread a = new Thread(() -> {
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() + "t" + " 自己持有A锁,期待获得B锁");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() + "t 获得B锁成功");
}
}
}, "a");
a.start();
new Thread(() -> {
synchronized (lockB)
{
System.out.println(Thread.currentThread().getName()+"t"+" 自己持有B锁,期待获得A锁");
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
synchronized (lockA)
{
System.out.println(Thread.currentThread().getName()+"t 获得A锁成功");
}
}
},"b").start();
}
}
运行结果:代码无法结束运行
5.3.3、如何排查死锁
jps命令定位进程编号
jstack找到死锁查看
jstack 6488
不可以String同一把锁
String locka =“A”;
String lockb =“B”; 不可以
严禁这么做



