复习：多线程（锁）

最新推荐文章于 2024-03-13 17:20:58 发布
最新推荐文章于 2024-03-13 17:20:58 发布
阅读量384 收藏 1
点赞数 1
文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sunjiac/article/details/107469438
版权
本文详细解析了Java中synchronized关键字的底层实现原理，包括mutex lock的使用、锁升级策略、乐观锁与悲观锁的区别，以及自旋锁、公平锁的概念。同时，介绍了Java中的Lock接口，AQS队列式同步器，读写锁机制，以及ThreadLocal的使用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

synchronized背后的原理

  1. synchronized的底层是使用操作系统的mutex lock实现的
  2. 当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
  3. 运行的线程数量越多，性能下降越快(归还对象锁的时候，就有越多的线程不停的在被唤醒、阻状态切换)
  4. 同步代码执行时间越短，性能下降也较快

Synchronized作用范围

  1. 作用于方法时，锁住的是对象的实例(this)；
  2. 当作用于静态方法时，锁住的是Class实例，又因为Class的相关数据存储在永久带PermGen （jdk1.8 则是 metaspace），永久带是全局共享的，因此静态方法锁相当于类的一个全局锁， 会锁所有调用该方法的线程；
  3. 代码块使用 synchronized 修饰的写法，使用代码块，如果传入的参数是 this，那么锁定的也是当前的对象：

对象锁(monitor)机制

  1. 每个对象都有个 monitor 对象，加锁就是在竞争 monitor 对象，代码块加锁是在前后分别加

    上 monitorenter 和 monitorexit 指令来实现的，方法加锁是通过一个标记位来判断的

  2. 关于 monitorenter 和 monitorexit 的作用，我们可以抽象地理解为每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。

  3. 当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

    • 如果目标锁对象的计数器为 0，那么说明它没有被其他线程所持有。在这个 情况下，Java 虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加 1。
    • 在目标锁对象的计数器不为 0 的情况下，如果锁对象的持有线程是当前线程，那么 Java 虚拟机可以将 其计数器加 1，否则需要等待，直至持有线程释放该锁。

  4. 当执行 monitorexit 时:Java 虚拟机则需将锁对象的计数器减 1。当计数器减为 0 时，那便代表该锁已经被释放掉了。

乐观锁、悲观锁、自旋锁、非公平锁、公平锁

乐观锁：乐观锁假设认为数据一般情况下不会产生并发冲突，所以在数据进行提交更新的时候，才会正式对数据是 否产生并发冲突进行检测，如果发现并发冲突了，则让返回用户错误的信息，让用户决定如何去做。 设计上总是乐观的认为数据修改大部分场景都是没有线程并发修改，少量情况下才存在。线程安全上采取版本号来控制------用户自己判断版本号，并处理。

悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样 别人想拿这个数据就会阻塞直到它拿到锁。 悲观的认为总是有其他线程并发修改，每次都是加锁操作

自旋锁：如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁 的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋）， 等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗。

非公平锁：**JVM 按随机、就近原则分配锁的机制则称为不公平锁，**ReentrantLock 在构造函数中提供了 是否公平锁的初始化方式，默认为非公平锁。非公平锁实际执行的效率要远远超出公平锁，除非 程序有特殊需要，否则最常用非公平锁的分配机制。

  1. 非公平锁性能比公平锁高 5~10 倍，因为公平锁需要在多核的情况下维护一个队列

  2. Java 中的 synchronized 是非公平锁，ReentrantLock 默认的 lock()方法采用的是非公平锁

公平锁：指的是锁的分配机制是公平的，通常先对锁提出获取请求的线程会先被分配到锁，

如何实现实现原子操作

CAS

CAS: 全称Compare and swap，字面意思:”比较并交换“，CAS操作（又称为无锁操作）是一种乐观锁策略， 它假设所有线程访问共享资源的时候不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的 操作。

操作过程：

CAS比较交换的过程可以通俗的理解为CAS(V,O,N)，包含三个值分别为：V 内存地址存放的实际值；O

预期的值（旧值）；N 更新的新值。

  • 当V和O相同时，也就是说旧值和内存中实际的值相同表明该值没 有被其他线程更改过，即该旧值O就是目前来说最新的值了，自然而然可以将新值N赋值给V。
  • 当V 和O不相同时，表明该值已经被其他线程改过了则该旧值O不是最新版本的值了，所以不能将新值N赋给 V，返回V即可。
  • 当多个线程使用CAS操作一个变量时，只有一个线程会成功，并成功更新，其余会失 败。失败的线程会重新尝试，当然也可以选择挂起线程。

应用场景：

CAS只适用于线程冲突较少的情况下使用

采取CAS的API：

  1. java.util.concurrent.atomic,原子性的并发包下的api
  2. synchronized中，多个线程不同时间点执行代码块时，jdk优化会采取CAS
  3. 其他的，如jdk1.8版本中ConcurrentHashMap实现，put操作室，节点为空，采取CAS

继续CAS实现的类：

public class AtomicInteger { 
    public final int incrementAndGet() { 
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1; 
    } 
}
public class Unsafe { 
    public final int getAndAddInt(Object var1, long var2, int var4) { 
        int var5; 
        do {
            var5 = this.getIntVolatile(var1, var2); 
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); 
        return var5; 
    } 
}

CAS的问题

1.ABA问题 ：因为CAS会检查旧值有没有变化，这里存在这样一个有意思的问题。比如一个旧值A变为了B，然后再变成A，刚好在做CAS时检查发现旧值并没有变化依然为A，但是实际上的确发生了 变化。

解决：添加一个版本号可以解决。在JDK1.5后的 atomic包中提供了AtomicStampedReference来解决ABA问题

2.自旋会浪费大量的处理器资源

解决：JVM给出的方案是自适应自旋，根据以往自旋等待时能否获取锁，来动态调整自旋的时间(循环

数)。

synchronized优化

JVM 将 synchronized 锁分为 无锁、偏向锁、轻量级锁、重量级锁 (状态级别从低到高)

  1. 锁可以升级但不能降级
  2. 目的是为了提高获得锁和释放锁的效率

无锁没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改 失败的线程会不断重试直到修改成功。

偏向锁对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁 带来的性能开销。 针对同一个线程再次申请已持有的对象锁。实现原理: CAS

轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。

  • 当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量 级锁；
  • 当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。
  • 大概率在同一个时间点，只有线程申请对象锁。实现原理: CAS

重量级锁指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。 重量级锁通过对象内部的监视器（monitor）实现，而**其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，**操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。

  • 大概率是在同一个时间点，多个线程竞争同-个对象锁。
  • 缺点:涉及到操作系统的调度、 用户态到内核态切换，开销非常大，线程会阻塞、唤醒

比较：
在这里插入图片描述

其他优化方案：

锁粗化：一个线程对同一个对象锁反复获取释放的操作，中间没有其他受影响代码时，可以合并为一个锁

public class Test{ 

    private static StringBuffer sb = new StringBuffer(); 

    public static void main(String[] args) { 

        sb.append("a"); 

        sb.append("b"); 

        sb.append("c"); 

    } 

}

锁消除：临界区代码中，没有对象逃逸出当前线程，说明本身是线程安全的操作，可以直接删除锁(不使用锁)

public class Test{ 
    public static void main(String[] args) { 
        StringBuffer sb = new StringBuffer(); 
        sb.append("a").append("b").append("c"); 
    } 
}

死锁

概念：

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
死锁产生的四个必要条件：

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了 一个等待环路

总结：至少有两个线程，互相持有对方申请的对象锁，造成互相等待。导致没法继续执行

解决：

① 资源一次性分配（破坏请求与保持条件）

② 可剥夺资源：在线程满足条件时，释放掉已占有的资源

③ 资源有 序分配：系统为每类资源赋予一个编号，每个线程按照编号递 请求资源，释放则相反

检测死锁的手段：

使用jdk的监控工具，比如jconsole、jstack查看线程状态

Lock锁

  1. 失去了像synchronize关键字隐式加锁解锁的便捷性，但是却拥有了锁获取和释放的可操作性，可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。
  2. synchronized同步块执行完成或者遇到异常是锁会自动释放，而lock必须调用unlock()方法释放锁，因此在finally块中释放锁
  3. 实现原理：AQS（队列式的同步器）
public static Lock LOCK = new ReentrantLock();
public static void t3(){
    try {
        LOCK.lock();//=synchronized()加锁的代码
        //执行业务
        while(库存达到上限){
            CONDITION.await();//=synchronized锁对象.wait()
        }
        System.out.println("t3");
    } finally {
        LOCK.unlock();
    }
}

synchronized与Lock的区别

  1. synchronized是关键字，而Lock是一个接口。
  2. synchronized会自动释放锁，而Lock必须手动释放锁。
  3. synchronized是不可中断的，Lock可以中断也可以不中断。
  4. 通过Lock可以知道线程有没有拿到锁，而synchronized不能。
  5. synchronized能锁住方法和代码块，而Lock只能锁住代码块。
  6. Lock可以使用读锁提高多线程读效率。
  7. synchronlzed是非公平锁，ReentrantLock可以控制是否是公平锁。

API

Semaphore：

Semaphore 是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信 号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore 可以用来 构建一些对象池，资源池之类的，比如数据库连接池

public static void main4(String[] args) throws InterruptedException {
    Semaphore s=new Semaphore(0);
    for(int i=0;i<20;i++){
        Thread t=new Thread(()->{
            System.out.println(Thread.currentThread().getName());
            s.release();//资源量+1
        });
        t.start();
    }
    s.acquire(20);//获取到20个资源后，才会继续往下执行
    System.out.println("执行完毕"+Thread.currentThread().getName());
}

public static void main(String[] args) throws InterruptedException {
    //模拟服务端接收客户端黄体酮请求：只有1000个并发
    // （在一个时间点，客户端任务数达到1000，再有客户端请求，将阻塞等待）
    Semaphore s=new Semaphore(1000);
    for(;;){
        Thread t=new Thread(()->{
            try {
                s.acquire();
                //模拟每个线程处理客户端http请求
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                s.release();
            }


        });
        t.start();
    }
}
CountDownLatch

好像跑步比赛，10个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能公布成绩。

public static void main3(String[] args) throws InterruptedException {
    CountDownLatch cd1=new CountDownLatch(20);//计数器的初始值
    for(int i=0;i<20;i++){
        Thread t=new Thread(()->{
            System.out.println(Thread.currentThread().getName());
            cd1.countDown();//计数器的值-1
        });

        t.start();
    }
    cd1.await();//当前线程阻塞等待，直到计数器的值为0
    System.out.println("执行完毕"+Thread.currentThread().getName());
}

Condition

作用线程间通信：

public static Lock LOCK = new ReentrantLock();
public static Condition CONDITION = LOCK.newCondition();

public static void t3(){
    try {
        LOCK.lock();//=synchronized()加锁的代码
        //执行业务
        while(库存达到上限){
            CONDITION.await();//=synchronized锁对象.wait()
        }
        System.out.println("t3");
        CONDITION.signal();//=synchronized锁对象.notify()
        CONDITION.signalAll();//=synchronized锁对象.notifyAll()
    } finally {
        LOCK.unlock();
    }
}

AQS

  1. AQS则实现了对同步状态的管理，以及对阻塞线程进行排队，等待通知等等一些底层的实现处理

  2. AQS的核心也包括了这些方面:同步队列，独占式锁的获取和释放，共享锁的获取和释放以及可中断

    锁，超时等待锁获取这些特性的实现，

同步队列：

AQS中的同步队列则是通过链式方式进行实现 一个双向队列

AQS实际上通过头尾指针来管理同步队列，同时实现包括获取锁失败的线程进行入队，释放锁 时对同步队列中的线程进行通知等核心方法。其示意图如下：

在这里插入图片描述

读写锁

读写锁允许同一时刻被多个读线程访问，但是在写线程 访问时，所有的读线程和其他的写线程都会被阻塞

写锁：

  1. 在同一时刻写锁是不能被多个线程所获取，很显然写锁 是独占式锁，而实现写锁的同步语义是通过重写AQS中的tryAcquire方法实现的
  2. 写锁释放通过重写AQS的tryRelease方法

读锁：

  1. 读锁不是独占式锁，即同一时刻该锁可以被多个读线程获取也就是一种共享式锁，通过重写AQS的

    tryAcquireShared方法和tryReleaseShared方法

  2. 读锁释放的实现主要通过方法tryReleaseShared

ThreadLocal

  1. ThreadLocal 用于提供线程局部变量，在多线程环境可以保证各个线程里的变量独立于其它线程里的变 量。也就是说 ThreadLocal 可以为每个线程创建一个【单独的变量副本】，相当于线程的 private static 类型变量。
  2. ThreadLocal 的作用和同步机制有些相反：同步机制是为了保证多线程环境下数据的一致性；而 ThreadLocal 是保证了多线程环境下数据的独立性。
private static String commStr;
private static ThreadLocal<String> threadStr = new ThreadLocal<String>();
public static void main(String[] args) {
    commStr = "main";
    threadStr.set("main");
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            commStr = "thread";
            threadStr.set("thread");
        }
    });
    thread.start();
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(commStr);
    System.out.println(threadStr.get());
}

从运行结果可以看出，对于 ThreadLocal 类型的变量，在一个线程中设置值，不影响其在其它线程中的值。也就是说 ThreadLocal 类型的变量的值在每个线程中是独立的。

sunjiac
关注
高并发 - 3.锁及其原理
举目沧桑的博客
07-29 3605
Java内置锁是一个互斥锁，这就意味着最多只有一个线程能够获得该锁，当线程B尝试去获得线程A持有的内置锁时，线程B必须等待或者阻塞，直到线程A释放这个锁，如果线程A不释放这个锁，那么线程B永远等待下去 Java中每个对象都可以用作锁，这些锁称为内置锁。线程进入同步代码块或方法时会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁保护的同步代码块或方法
java程序员进阶：详解多线程之分布式锁及其实现方式
玩赚AI大模型的博客
08-09 265
欢迎关注专栏：Java架构技术进阶。里面有大量batj面试题集锦，还有各种技术分享，如有好文章也欢迎投稿哦。 微信公众号：慕容千语的架构笔记。欢迎关注一起进步。 很多小伙伴在学习Java的时候，总是感觉Java多线程在实际的业务中很少使用，以至于不会花太多的时间去学习，技术债不断累积！等到了一定程度的时候对于与Java多线程相关的东西就很难理解，今天需要探...
线程锁
wyc_595998412的博客
08-27 3456
一、多线程-同步函数的锁是this /* 同步函数用的是哪一个锁呢？ 函数需要被对象调用。那么函数都有一个所属对象引用。就是this。 所以同步函数使用的锁是this。 通过该程序进行验证。 使用两个线程来买票。 一个线程在同步代码块中。    这两个的锁不一样 一个线程在同步函数中。 都在执行买票动作。 */ class Ticket implements Runnable {     priv...
关于线程中的锁
w669600的博客
09-21 3206
锁类型 可重入锁：广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。即在执行对象中所有同步方法不用再次获得锁。ReentrantLock和synchronized都是可重入锁。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调...
线程安全——锁
Z1591090的博客
07-19 2083
前言 多线程利用CPU多核的性质。能并行执行任务，提高效率。但随着多线程的使用，对于资源的静态以及数据的操作都可能存在风险，所以有必要在操作时保证线程安全。而线程的安全主要是依靠各种锁，锁的种类有很多，有各自的优缺点，需要开发者自己权衡利弊，选择合适的锁，来搭配多线程的使用。 NSLock ...
Java多线程复习：线程创建与调度
"E05_多线程复习.pdf 是一份关于Java多线程的复习资料，涵盖了进程、线程的基本概念，线程的创建方式，线程调度，以及线程安全和JUC编程的相关知识点。" 在计算机系统中，**进程**是一个正在执行的应用程序，它拥有...
操作系统复习：进程和线程的理解串记
最新发布
05-30
### 操作系统复习：进程和线程的理解串记 #### 进程与线程的概念解析 **进程**是操作系统中的一个基本单位，它是指正在执行的程序实例。进程由程序段、数据段以及进程控制块（PCB）组成。PCB可以视为进程的身份...
Java面试复习关键点：多线程与集合框架
这篇内容主要针对的是面试复习，涵盖了Java编程语言中的关键概念和技术，旨在帮助求职者准备面试，提升获得Offer的机会。 在Java编程中，线程管理是至关重要的一个部分。线程是程序执行的最小单位，它可以并行执行...
E05_多线程复习.pdf
11-02
在计算机科学中，多线程是并发编程的重要概念，它允许多个任务在同一时间执行，提高了系统的效率和响应性。本文将深入探讨多线程的相关知识点。 1. **进程与线程** - **进程**：是操作系统分配资源的基本单位，每...
头歌Linux系统编程之c编程入门
11-20
头歌linux之c编程入门
多线程中的锁
qq_66292058的博客
03-13 1968
在了解什么是锁之前，我们先来看一下这样一段代码//创建变量i//我们创建两个线程,分别让i自增10000次j < 10000;j++) {i++;});j < 10000;j++) {i++;});t1.start();t2.start();try {//等待两个线程执行完成t2.join();t1.join();//打印i的值按照正常的逻辑，两个线程都让i自增了10000次，i最终的结果应该是20000才对，但事实真是如此吗？我们来看一下代码的运行结果。
（一）线程安全问题-线程锁（synchronized的使用）
roothahh的博客
03-24 8131
（一）线程安全问题诱因 存在有共享数据 存在有多个线程访问这些共享数据 解决方法：同一时刻共享数据只能由一个线程访问，其他线程要等到该线程处理完共享数据后才能对该线程进行操作 (二）线程锁-synchronized 线程锁的两个特性 互斥性：同一时间只能有一个对象持有线程锁，通过这种特性实现多线程的协调机制。同一时间只有一个线程对需要同步的代码块进行访问，也成为原子性 可见性：必须确保在锁释放之前，其对于共享变量的修改对下一个获得该锁的线程是可见的，否则另一个线程可能是在本地缓存的某个副本上进行，
java中的线程与锁
Better0417的博客
07-19 359
一、线程 1、什么叫线程 （1）CPU进行调度的最小单位 （2）进程：运行中的运用 （3）一个进程中至少一条线程，该线程由JVM发起，称之为主线程。 （4）线程的生命周期 1）创建线程对象： 新生 new born 2）调用start方法后: 就绪 ready 3）CPU调度后： 运行running 阻塞 blocked（sleep/wait(100)->notify） 阻塞状态正常结束后，进入就绪态。 4）run方法结束 ： 死亡 dead（
Java 基础--线程 锁 线程池
danfengw的博客
12-25 542
线程 1 概念 进程与线程的区别： 进程：是资源分配的最小单位 线程：是cpu调度的最小单位 进程是抢占处理机的调度单位，线程属于某个进程，共享其资源 线程只由堆栈寄存器 程序计数器 和 TCB组成 进程与线程的区别 线程不能看作独立应用，而进程可以看作独立应用 进程有独立的地址空间，相互不影响，而线程只是进程的不同执行路径 线程没有独立的地址空间，多进程的程序比多线程程序健壮 进程的切换比线程切换开销大 线程中start 与 run 方法的区别 start() 会创建一个新的子线程并启动 run（）只是T
线程安全与锁
w1316022737的博客
10-30 378
目前CPU的运算速度已经达到百亿次每秒, 甚至更高的量级, 在现实场景中, 为了提高生产率和高效的完成任务, 处处均采用多线程和并发的运作方式 并发是指在某个时间段内, 多任务交替处理的能力, 所谓不患寡而患不均, 每个CPU不可能只顾着执行某个进程, 让其他线程进入等待状态, 所以, CPU把可执行时间均匀的分成若干份, 每个线程执行一段时间后, 记录当前的工作状态, 释放相关的执行资源并进入等...
【java并发】线程锁技术的使用
热门推荐
武哥聊编程
06-04 1万+
Lock锁好比传统线程模型中的synchronized技术，但是比sychronized方式更加面向对象，与生活中的锁类似，锁本身也应该是个对象。两个线程执行的代码片段如果要实现同步互斥的效果，它们必须用同一个Lock对象。锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。这一篇博文主要总结一下线程技术中Lock锁的使用。 1. Lock的简单使用 　　有了synchronize
线程的方法与线程锁
梦风心雨的博客
01-04 3747
1、线程的五个状态 新建(NEW)： 新创建了一个线程对象 可运行(RUNNABLE)： 调用了start方法，线程就处于可执行状态。 运行(RUNNING)： 可执行的线程对象获得cpu的时间片，被cpu调度执行。 阻塞(BLOCKED)： 线程由于某种原因放弃了cpu的使用权，暂时停止运行。 死亡(DEAD)： 线程运行完毕或者因为异常退出了run方法，停止了运行。 2、线程的常用方法 1、yeild方法（礼让） 2、join方法（插队） 3、sleep方法（睡眠） 4、 ...
线程并发——锁（超简单）
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，熟悉瑞芯微、全志、恩智浦等平台。
02-23 1788
什么是互斥锁呢，我给大家举个例子，我们可以想象成是车站的座位，然后把线程比喻成一个人，你进车站候车的时候，你就要先找到没有人的座位，然后坐下去（表示你正在使用），这样其他的人（其他的线程）就无法再使用这个座位了，如果想要使用该座位就需要你站起来，别人才可以使用。并发：同时发生在生活中，可能会有多个执行单元，同时访问同一个资源。比如座位。使用锁（互斥锁）来保护资源互斥锁：一个时刻值允许一个执行单元访问共享资源1.定义并初始化一把锁2.访问共享资源前。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值