栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

3、Java“锁”事

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

3、Java“锁”事

1、一些面试题
  1. Java加锁有哪几种锁?synchronized,偏向锁
  2. 简单说说lock
  3. 项目中哪个地方用了countdownlanch,怎么使用?
2、从轻松的乐观锁和悲观锁开讲 2.1、悲观锁

认为自己在使用数据的时候一定有别的线程来修改数据,因此在获取数据的时候会先加锁,确保数据不会被别的线程修改。 

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 自旋实现的。   

适合读操作多的场景,不加锁的特点能够使其读操作的性能大幅提升。

乐观锁则直接去操作同步资源,是一种无锁算法,得之我幸不得我命,再抢

乐观锁一般有两种实现方式:

  1. 采用版本号机制
  2. CAS(Compare-and-Swap,即比较并替换)算法实现
3、通过8种情况演示锁运行案例,看看我们到底锁的是什么 3.1、承前启后的复习一下

锁相关的8种案例演示

看看JVM中对应的锁在哪里?

 

3.2、synchronized有三种应用方式

JDK源码(notify方法)说明举例

8种锁的案例实际体现在3个地方

(表格多了一种)

Synchronized

对象锁(实例锁)

类锁(全局锁)

synchronized method(){}

synchronized(this){}

static synchronized method(){}

synchronized(class){}

在同个实例对象内,所属线程独占对象锁,其他线程阻塞;不同的实例对象内无影响。

在同个类内,所属线程独占类锁,其他线程阻塞。

  • 作用于实例方法,当前实例加锁,进入同步代码前要获得当前实例的锁;
  • 作用于代码块,对括号里配置的对象加锁。
  • 作用于静态方法,当前类加锁,进去同步代码前要获得当前类对象的锁; 
3.3、从字节码角度分析synchronized实现 3.3.1、javap -c ***.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、是什么

死锁是指两个或两个以上的线程在执行过程中 , 因争夺资源而造成的一种 互相等待的现象 , 若无外力干涉那它们都将无法推进下去,如果系统资源充足,进程的资源请求都能够得到满足,死锁出现的可能性就很低,否则就会因争夺有限的资源而陷入死锁。  

 

产生死锁主要原因:

  1. 系统资源不足
  2. 进程运行推进的顺序不合适
  3. 资源分配不当
5.3.2、请写一个死锁代码case
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”;  不可以 

严禁这么做

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/967342.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号