• 第四章：Java琐事

    乐观锁和悲观锁

    悲观锁

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

    • 悲观锁的实现方式

      • synchronized关键字
      • Lock的实现类都是悲观锁

    • 适合写操作多的场景，先加锁可以保证写操作时数据正确。显示的锁定之后再操作同步资源。

    //=============悲观锁的调用方式
public synchronized void m1()
{
    //加锁后的业务逻辑......
}

// 保证多个线程使用的是同一个lock对象的前提下
ReentrantLock lock = new ReentrantLock();
public void m2() {
    lock.lock();
    try {
        // 操作同步资源
    }finally {
        lock.unlock();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    乐观锁

    • 乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作
    • 乐观锁的实现方法：
      • 版本号机制Version。（只要有人提交了就会修改版本号，可以解决ABA问题）
      • 最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。
    • 适合读操作多的场景，不加锁的性能特点能够使其操作的性能大幅提升。
    //=============乐观锁的调用方式
// 保证多个线程使用的是同一个AtomicInteger
private AtomicInteger atomicInteger = new AtomicInteger();
atomicInteger.incrementAndGet();


    • 1
    • 2
    • 3
    • 4
    • 5

    八种案例演示synchronized到底锁的是什么

    阿里巴巴多锁的要求：

    • 【强制】高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。
    • 简单一句话：能不用就不用，即使用尽量将 synchronized 的同步代码快缩小。

    演示八种案例：

    /**
 *
 * Author: YZG
 * Date: 2022/11/13 21:22
 * Description:
 * 1 标准访问，先打印短信还是邮件
 * --------- sendSMS
 * --------- sendEmail
 *
 * 2停4秒在短信方法内，先打印短信还是邮件
 * --------- sendSMS
 * --------- sendEmail
 * 3新增普通的hello方法,是先打短信还是hello
 *
 * --------- sendHello
 * --------- sendSMS
 * 4现在有两部手机，先打印短信还是邮件
 *
 *--------- sendEmail
 * --------- sendSMS
 *
 * 5两个静态同步方法, 1部手机,先打印短信还是邮件
 *--------- sendSMS
 * --------- sendEmail
 *
 * 6两个静态同步方法, 2部手机，先打印短信还是邮件
 *--------- sendSMS
 * --------- sendEmail
 *
 * 7 1个静态同步方法1个普通同步方法，1部手机，先打印短信还是邮件
 *--------- sendEmail
 * --------- sendSMS
 *
 * 8 1个静态同步方法, 1个普通同步方法, 2部手机,先打印短信还是邮件
 *--------- sendEmail
 * --------- sendSMS
 */
public class Demo06 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        // Phone phone2 = new Phone();

        new Thread(Phone::sendEMS,"t1").start();

        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(phone::sendEmail,"t2").start();
    }
}

class Phone {

    public synchronized void sendEMS(){
        // try {
        //     TimeUnit.SECONDS.sleep(4);
        // } catch (InterruptedException e) {
        //     e.printStackTrace();
        // }
        System.out.println("--------- sendSMS");
    }

    public  synchronized  void sendEmail() {
        System.out.println("--------- sendEmail");
    }

    public  void sendHello() {
        System.out.println("--------- sendHello");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    总结

    • 对于普通同步方法，锁是当前实例对象。
    • 对于静态同步方法，锁是当前类的Class对象。
    • 对于同步方法块,锁是Synchoni zed括号里配置的对象

    字节码角度分析 Synchronized

    反编译指令：

    • 文件反编译javap -c ***.class文件反编译，-c表示对代码进行反汇编

    • 假如需要更多信息 javap -v ***.class ，-v即-verbose输出附加信息（包括行号、本地变量表、反汇编等详细信息）

    JVM 指令的学习笔记： JVM

    synchronized 同步代码块

    代码

    public class LockSyncTest {

    private Object obj = new  Object();

    public void m1() {
        synchronized (obj) {
            System.out.println("hello");
        }

    }

    public static void main(String[] args) {

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    字节码

    image-20221121162454284

    结论：

    synchronized 经过编译之后，会在同步代码块前后生成 monitorenter 和 monitorexit 俩个指令。在执行 monitorenter 指令时，会尝试获取对象锁，如果对象锁被占用，或者锁对象的持有线程是当前线程，锁的计数器就会 +1，响应的执行 monitorexit 指令时，锁的计数器会 -1 ， 计数器为 0 时 表示 锁已经被释放。

    第二个 monitorexit 是为了防止同步代码块出现异常。

    synchronized 同步方法

    代码：

        public synchronized void m2() {
            System.out.println("hello");

    }

    • 1
    • 2
    • 3
    • 4

    字节码；

    image-20221121163633383

    image-20221121163739471

    结论：

    通过字节码我们可以看，同步方法是隐式的，不需要JVM生成字节码指令，在是在访问标志中指出。调用方法时，调用指令会检查方法的 ACC_ SYNCHRONIZED 访问标志是否设置。

    • 如果设置了，执行线程将先持有同步锁，然后执行方法。最后在方法完成(无论是正常完成还是非正常完成)时释放同步锁。

    静态同步方法与普通同步方法的区别就是访问标识中加了 static

    image-20221121164119749

    为什么任意一个对象都可以是锁？

    在 Java 中任意一个对象都可以是锁，这是为什么呢？

    多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。

    其实看到对象的内存结构就很清晰明了，每个对象的对象头都包含 锁状态标志 和 线程持有的锁

    image-20221121165342470

    另一方面，从C源码中可以看出：

    • ObjectMonitor.java→ObjectMonitor.cpp→objectMonitor.hpp
      • ObjectMonitor.cpp中引入了头文件，（include）objectMonitor.hpp
    140行
  ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //用来记录该线程获取锁的次数
    _waiters      = 0,
    _recursions   = 0;//锁的重入次数
    _object       = NULL;
    _owner        = NULL; //------最重要的----指向持有ObjectMonitor对象的线程，记录哪个线程持有了我
    _WaitSet      = NULL; //存放处于wait状态的线程队列
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ;//存放处于等待锁block状态的线程队列
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
  }



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 追溯底层可以发现每个对象天生都带着一个对象监视器。

    公平锁和非公平锁

    公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

    • 优点：所有的线程都能得到资源，不会饿死在队列中。
    • 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

    非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

    • 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
    • 缺点：可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

    synchronized 为非公平锁，ReentrantLock默认也是非公平锁，可通过设置参数 true 创建公平锁

    买票案例代码：

    //第一步  创建资源类，定义属性和和操作方法
class LTicket {
    //票数量
    private int number = 30;

    // 设置公平锁
    private final ReentrantLock lock = new ReentrantLock(true);
    //卖票方法
    public void sale() {
        //上锁
        lock.lock();
        try {
            //判断是否有票
            if(number > 0) {
                System.out.println(Thread.currentThread().getName()+" ：卖出"+(number--)+" 剩余："+number);
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

public class Demo07 {
    //第二步 创建多个线程，调用资源类的操作方法
    //创建三个线程
    public static void main(String[] args) {

        LTicket ticket = new LTicket();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    为什么会有公平锁/非公平锁的设计？为什么默认是非公平？

    1. 恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显的。所以非公平锁能更充分的利用CPU 的时间片，尽量减少 CPU 空闲状态时间。
    2. 使用多线程很重要的考量点是线程切换的开销，当采用非公平锁时，当1个线程请求锁获取同步状态，然后释放同步状态，因为不需要考虑是否还有前驱节点，所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大，所以就减少了线程的开销。

    可重入锁（递归锁）

    什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁 (同一把锁) 而不会出现 死锁。

    synchronized 和 ReentrantLock 都是可重入锁

    隐式锁synchronized

    同步代码块方式：

    public class LockSyncTest02 {
    public static void main(String[] args) {
        Object o = new Object();
        new Thread(() -> {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + " .....外层调用");
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + " .....中层调用");
                    synchronized (o) {
                        System.out.println(Thread.currentThread().getName() + " .....内层调用");
                    }
                }
            }
        }, "t1").start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    输出结果：

    t1 .....外层调用
t1 .....中层调用
t1 .....内层调用

    • 1
    • 2
    • 3

    同步方法方式：

    public class LockSyncTest02 {

    public synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + " .....m1 come in");
        m2();
        System.out.println(Thread.currentThread().getName() + " .....m1 end");

    }

    private synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + " .....m2 come in");
        m3();
        System.out.println(Thread.currentThread().getName() + " .....m2 end");

    }

    private synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + " .....m3 come in");
        System.out.println(Thread.currentThread().getName() + " .....m3 end");

    }

    public static void main(String[] args) {
        LockSyncTest02 lockSyncTest02 = new LockSyncTest02();
        lockSyncTest02.m1();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    输出结果：

    main .....m1 come in
main .....m2 come in
main .....m3 come in
main .....m3 end
main .....m2 end
main .....m1 end

Process finished with exit code 0


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    显示锁Lock

    注意事项：

    • 由于Lock需要手动上锁释放锁，因此上锁和释放锁的次数一定要对应上。否则在多线程的场景下，很容易造成阻塞，甚至死锁。
    public class Demo09 {
    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock(); // 上锁
            System.out.println(Thread.currentThread().getName() + " 第一次获取锁");
            try {
                lock.lock(); // 上锁
                System.out.println(Thread.currentThread().getName() + " 第二次获取锁");
            } finally {
               lock.unlock(); // 解锁
            }
        } finally {
            lock.unlock(); // 解锁
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    演示 Lock 出现阻塞的情况：

    由于主线程在第二次获取锁的时候，并没有手动释放锁，造成了t1线程一直处在阻塞状态

    public class LockTest {
    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock(); // 上锁
            System.out.println(Thread.currentThread().getName() + " 第一次获取锁");
            try {
                lock.lock(); // 上锁
                System.out.println(Thread.currentThread().getName() + " 第二次获取锁");
            } finally {
                // lock.unlock(); // 解锁
            }
        } finally {
            lock.unlock(); // 解锁
        }

        new Thread(() -> {
            lock.lock();
            System.out.println(Thread.currentThread().getName());
            lock.unlock();
        }, "t1").start();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    通过 jstack 命令查看 t1 线程的状态：

    image-20221121174716248

    image-20221121174643010一直在等待 main 线程释放锁。

    死锁及排查

    什么是死锁？

    不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

    image-20221121175456095

    演示死锁

    public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " 占用 o1，试图获取o2");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + " 占用 o2");
                }
            }
        }, "t1").start();


        new Thread(() -> {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 占用 o2，试图获取o1");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " 占用 o1");
                }
            }
        }, "t2").start();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    死锁产生的原因

    • 系统资源不足
    • 进程运行推进的顺序不合适
    • 资源分配不当

    死锁的排查

    更详细的JVM指令笔记： JVM

    命令行

    使用 jps + jstack

    image-20221121180712515

    可以看出死锁的线程：

    image-20221121180743433

    图形化界面

    控制台输入 JConsole，弹出如图界面，它是jdk内置的一个监视控制台。

    选中运行的类进行连接

    image-20221121180900316

    从这里也可以看出出现死锁

    image-20221121181014482

    总结

    指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp,C++实现的）

    在这里插入图片描述

    以下相当于一些前置知识

    写锁（独占锁）/读锁（共享锁）—— 见第十四章

    自旋锁SpinLock —— 见第八章

    无锁-独占锁-读写锁-邮戳锁 —— 见第十四章

    无锁-偏向锁-轻量锁-重量锁 —— 见第十二章

    各位彭于晏，如有收获点个赞不过分吧…✌✌✌

    Alt

    扫码关注公众号 【我不是秃神】 回复 JUC 可下载 MarkDown 笔记

  • 相关阅读:
    【C++进阶(七)】仿函数深度剖析&模板进阶讲解
    AI 引擎系列 1 - 从 AI 引擎工具开始（2022.1 更新）
    RabbitMQ学习（1）
    代码随想录——分割回文串 II
    【洛谷】P3377 【模板】左偏树（可并堆）
    Linux操作系统的内存使用方法详细解析
    ARMday02（汇编语法、汇编指令）
    MYSQL----innoDB存储引擎
    yarn包管理工具
    WPF 控件专题 ListBox 控件详解
  • 原文地址：https://blog.csdn.net/aetawt/article/details/128044910