当前位置： 首页 > news >正文

做网站推广每天加班/站长工具官网域名查询

news 2025/8/15 3:44:18
做网站推广每天加班,站长工具官网域名查询,建网站前途,彩票网站和app建设锁，从面试题说起在并发编程中有两个重要的概念：线程和锁。多线程是一把双刃剑，它在提高程序性能的同时，也带来了编码的复杂性，对开发者的要求也提高了一个档次。而锁的出现就是为了保障多线程在同时操作一组资源时的数…

5ac83bc67cefcc82bdbd7fe64510ae31.png

锁，从面试题说起

在并发编程中有两个重要的概念：线程和锁。

多线程是一把双刃剑，它在提高程序性能的同时，也带来了编码的复杂性，对开发者的要求也提高了一个档次。而锁的出现就是为了保障多线程在同时操作一组资源时的数据一致性。

当我们给资源加上锁之后，只有拥有此锁的线程才能操作此资源，而其他线程只能排队等待使用此锁。当然，在所有的面试中也都少不了关于“锁”方面的相关问题。

一个经典面试题是——

如何手动模拟一个死锁？谈谈你对锁的理解。

死锁是指两个线程同时占用两个资源，又在彼此等待对方释放锁资源。

8d10aed6b73530228b0469f5484286e0.png

死锁的代码演示如下：

import java.util.concurrent.TimeUnit;
public class LockExample {
    public static void main(String[] args) {
        deadLock(); // 死锁
    }
    /**
     * 死锁
     */
    private static void deadLock() {
        Object lock1 = new Object();
        Object lock2 = new Object();
        // 线程一拥有 lock1 试图获取 lock2
        new Thread(() -> {
            synchronized (lock1) {
                System.out.println("获取 lock1 成功");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 试图获取锁 lock2
                synchronized (lock2) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }).start();
        // 线程二拥有 lock2 试图获取 lock1
        new Thread(() -> {
            synchronized (lock2) {
                System.out.println("获取 lock2 成功");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 试图获取锁 lock1
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }).start();
    }
}

以上程序执行结果如下：

获取 lock1 成功
获取 lock2 成功

可以看出，线程一拥有锁 lock1 的同时试图获取 lock2，而线程二在拥有 lock2 的同时试图获取 lock1，这样就会造成彼此都在等待对方释放资源，于是就形成了死锁。

6c18a5a9bfcbab602e036795715993bc.png

锁是什么？

在并发编程中，当有多个线程同时操作一个资源时，为了保证数据操作的正确性，我们需要让多线程排队一个一个地操作此资源，而这个过程就是给资源加锁和释放锁的过程，就好像去公共厕所一样，必须一个一个排队使用，并且在使用时需要锁门和开门一样。

锁的概念不止出现在 Java 语言中，比如乐观锁和悲观锁其实很早就存在于数据库中了。锁的概念其实不难理解，但要真正地了解锁的原理和实现过程，才能打动面试官。

和锁相关的面试问题，还有以下几个：

什么是乐观锁和悲观锁？它们的应用都有哪些？乐观锁有什么问题？

什么是可重入锁？用代码如何实现？它的实现原理是什么？

什么是共享锁和独占锁？

悲观锁和乐观锁

悲观锁指的是数据对外界的修改采取保守策略，它认为线程很容易会把数据修改掉，因此在整个数据被修改的过程中都会采取锁定状态，直到一个线程使用完，其他线程才可以继续使用。

我们来看一下悲观锁的实现流程，以 synchronized 为例，代码如下：

public class LockExample {
    public static void main(String[] args) {
        synchronized (LockExample.class) {
            System.out.println("lock");
        }
    }
}

我们使用反编译工具查到的结果如下：

Compiled from "LockExample.java"
public class com.lagou.interview.ext.LockExample {
  public com.lagou.interview.ext.LockExample();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return
 
  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // class com/lagou/interview/ext/LockExample
       2: dup
       3: astore_1
       4: monitorenter // 加锁
       5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       8: ldc           #4                  // String lock
      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: aload_1
      14: monitorexit // 释放锁
      15: goto          23
      18: astore_2
      19: aload_1
      20: monitorexit
      21: aload_2
      22: athrow
      23: return
    Exception table:
       from    to  target type
           5    15    18   any
          18    21    18   any
}

可以看出被 synchronized 修饰的代码块，在执行之前先使用 monitorenter 指令加锁，然后在执行结束之后再使用 monitorexit 指令释放锁资源，在整个执行期间此代码都是锁定的状态，这就是典型悲观锁的实现流程。

乐观锁和悲观锁的概念恰好相反，乐观锁认为一般情况下数据在修改时不会出现冲突，所以在数据访问之前不会加锁，只是在数据提交更改时，才会对数据进行检测。

Java 中的乐观锁大部分都是通过 CAS(Compare And Swap，比较并交换)操作实现的，CAS 是一个多线程同步的原子指令，CAS 操作包含三个重要的信息，即内存位置、预期原值和新值。如果内存位置的值和预期的原值相等的话，那么就可以把该位置的值更新为新值，否则不做任何修改。

CAS 可能会造成 ABA 的问题，指的是，线程拿到了最初的预期原值 A，然而在将要进行 CAS 的时候，被其他线程抢占了执行权，把此值从 A 变成了 B，然后其他线程又把此值从 B 变成了 A，然而此时的 A 值已经并非原来的 A 值了，但最初的线程并不知道这个情况，在它进行 CAS 的时候，只对比了预期原值为 A 就进行了修改，这就造成了 ABA 的问题。

以警匪剧为例，假如某人把装了 100W 现金的箱子放在了家里，几分钟之后要拿它去赎人，然而趁他不注意的时候，一个小偷进来了，用空箱子换走了装满钱的箱子，当某人进来之后看到箱子还是一模一样的，他会以为这就是原来的箱子，就拿着它去赎人了，这种情况肯定有问题，因为箱子已经是空的了，这就是 ABA 的问题。

ABA 的常见处理方式是添加版本号，每次修改之后更新版本号。拿上面的例子来说，假如每次移动箱子之后，箱子的位置就会发生变化，而这个变化的位置就相当于“版本号”，当某人进来之后发现箱子的位置发生了变化就知道有人动了手脚，就会放弃原有的计划，这样就解决了 ABA 的问题。

JDK 在 1.5 时提供了 AtomicStampedReference 类也可以解决 ABA 的问题，此类维护了一个"版本号" Stamp，每次在比较时不止比较当前值还比较版本号，这样就解决了 ABA 的问题。

相关源码如下：

public class AtomicStampedReference {
    private static class Pair {
        final T reference;
        final int stamp; // “版本号”
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static  Pair of(T reference, int stamp) {return new Pair(reference, stamp);
        }
    }
    // 比较并设置
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp, // 原版本号
                                 int newStamp) { // 新版本号
        Pair current = pair;return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }
    //.......省略其他源码
}

可以看出它在修改时会进行原值比较和版本号比较，当比较成功之后会修改值并修改版本号。

小贴士：

乐观锁有一个优点，它在提交的时候才进行锁定的，因此不会造成死锁。

可重入锁

可重入锁也叫递归锁，指的是同一个线程，如果外面的函数拥有此锁之后，内层的函数也可以继续获取该锁。在 Java 语言中 ReentrantLock 和 synchronized 都是可重入锁。

下面我们用 synchronized 来演示一下什么是可重入锁，代码如下：

public class LockExample {
    public static void main(String[] args) {
        reentrantA(); // 可重入锁
    }
    /**
     * 可重入锁 A 方法
     */
    private synchronized static void reentrantA() {
        System.out.println(Thread.currentThread().getName() + "：执行 reentrantA");
        reentrantB();
    }
    /**
     * 可重入锁 B 方法
     */
    private synchronized static void reentrantB() {
        System.out.println(Thread.currentThread().getName() + "：执行 reentrantB");
    }
}

以上代码的执行结果如下：

main：执行 reentrantA
main：执行 reentrantB

从结果可以看出 reentrantA 方法和 reentrantB 方法的执行线程都是 main ，我们调用了 reentrantA 方法，它的方法中嵌套了 reentrantB，如果 synchronized 是不可重入的话，那么线程会被一直堵塞。

可重入锁的实现原理，是在锁内部存储了一个线程标识，用于判断当前的锁属于哪个线程，并且锁的内部维护了一个计数器，当锁空闲时此计数器的值为 0，当被线程占用和重入时分别加 1，当锁被释放时计数器减 1，直到减到 0 时表示此锁为空闲状态。

共享锁和独占锁

只能被单线程持有的锁叫独占锁，可以被多线程持有的锁叫共享锁。

独占锁指的是在任何时候最多只能有一个线程持有该锁，比如 synchronized 就是独占锁，而 ReadWriteLock 读写锁允许同一时间内有多个线程进行读操作，它就属于共享锁。

独占锁可以理解为悲观锁，当每次访问资源时都要加上互斥锁，而共享锁可以理解为乐观锁，它放宽了加锁的条件，允许多线程同时访问该资源。

推荐阅读：

搞定Java并发：为什么说只有1种实现线程的方法？

搞定Java并发：为什么说只有1种实现线程的方法？(下)

JVM 对锁做了什么优化？

面试官问我：每秒10W并发量如何确保不崩？

fb930cb5babf67797c0fd9c27445b3eb.png

http://www.lbrq.cn/news/1439929.html

相关文章：

  • wordpress 做购物网站/百度知道灰色词代发收录
  • 男朋友说是做竞彩网站维护的/b站引流推广网站
  • 建设景区网站推文/整合营销策略
  • 亿网行网站建设/网络优化工程师有前途吗
  • 网站为什么维护/朝阳区seo搜索引擎优化怎么样
  • wordpress nextgen gallery/网站seo提升
  • wordpress响应多少才正常/兰州seo优化
  • 太原网站优化教程/百度网站首页提交入口
  • 企业网站建设 建立作用/做网站企业
  • 合肥专业网站建设/简述如何对网站进行推广
  • 石家庄上门足疗/网站seo优化方案
  • 深圳网络seo优化/网站需要怎么优化比较好
  • 品牌网站建设仁術大蝌蚪/百度seo官方网站
  • 观澜网站建设/网站seo优化运营
  • 什么网站可以做实验室/精准ip地址查询工具
  • 抖音小程序推广怎么挂才有收益/哈尔滨关键词优化报价
  • 柳州网站建设33/大地seo视频
  • 辽宁城乡建设工程招标网(官网)/网站seo关键词优化技巧
  • 企业网站开发需要多钱/百度ocpc如何优化
  • 免费的ppt网站推荐/如何建立网页
  • 计算机专业网站建设实训日志/网站seo入门基础教程
  • 销售网站免费做/哈尔滨电话本黄页
  • 建站之星极速版/晨阳seo顾问
  • 如何开网站建设公司/沈阳网络优化培训
  • 河北手机网站制作公司/武汉网站排名提升
  • 公司网站建设好处/盘多多搜索引擎入口
  • 珠海网站建设制作怎么收费/免费python在线网站
  • 搭建h5流程/江苏搜索引擎优化公司
  • 计算机的网站建设/查询网站信息
  • 怎么用java做html5网站/百度首页排名代发
  • 【代码随想录day 19】 力扣 450.删除二叉搜索树中的节点
  • 基于SpringBoot+Vue的智能消费记账系统（AI问答、WebSocket即时通讯、Echarts图形化分析）
  • HarmonyOS NDK的JavaScript/TypeScript与C++交互机制
  • LeetCode Day5 -- 栈、队列、堆
  • SQL 生成日期与产品的所有组合：CROSS JOIN（笛卡尔积）
  • VUE+SPRINGBOOT从0-1打造前后端-前后台系统-会议记录