自旋锁和mutex有什么区别 [问题点数:25分,结帖人liuzu2016]

Bbs1
本版专家分:10
结帖率 82.98%
Bbs2
本版专家分:165
Bbs2
本版专家分:147
Bbs12
本版专家分:377366
Blank
状元 2017年 总版技术专家分年内排行榜第一
Blank
榜眼 2014年 总版技术专家分年内排行榜第二
Blank
探花 2013年 总版技术专家分年内排行榜第三
Blank
进士 2018年总版新获得的技术专家分排名前十
2012年 总版技术专家分年内排行榜第七
Bbs2
本版专家分:108
Bbs9
本版专家分:67244
版主
Blank
红花 2013年8月 Linux/Unix社区大版内专家分月排行榜第一
2012年11月 Linux/Unix社区大版内专家分月排行榜第一
2012年10月 Linux/Unix社区大版内专家分月排行榜第一
2012年9月 Linux/Unix社区大版内专家分月排行榜第一
2012年7月 Linux/Unix社区大版内专家分月排行榜第一
2012年6月 Linux/Unix社区大版内专家分月排行榜第一
2012年5月 Linux/Unix社区大版内专家分月排行榜第一
2011年11月 Linux/Unix社区大版内专家分月排行榜第一
Blank
黄花 2013年6月 Linux/Unix社区大版内专家分月排行榜第二
2013年5月 Linux/Unix社区大版内专家分月排行榜第二
2013年3月 Linux/Unix社区大版内专家分月排行榜第二
2013年1月 Linux/Unix社区大版内专家分月排行榜第二
2012年12月 Linux/Unix社区大版内专家分月排行榜第二
2012年8月 Linux/Unix社区大版内专家分月排行榜第二
2011年12月 Linux/Unix社区大版内专家分月排行榜第二
2011年10月 C/C++大版内专家分月排行榜第二
2011年10月 Linux/Unix社区大版内专家分月排行榜第二
Blank
蓝花 2012年6月 C/C++大版内专家分月排行榜第三
2012年6月 PHP大版内专家分月排行榜第三
2012年5月 C/C++大版内专家分月排行榜第三
2012年3月 Linux/Unix社区大版内专家分月排行榜第三
2012年2月 Linux/Unix社区大版内专家分月排行榜第三
2011年11月 C/C++大版内专家分月排行榜第三
自旋锁与互斥锁的对比、手工实现自旋锁
本文之前,我只是对<em>自旋锁</em>有所了解,知道它是做什么的,但是没有去测试实现过,甚至以为<em>自旋锁</em>只有kernel用这个,今天才发现POSIX有提供<em>自旋锁</em>的接口。下面我会分析一下<em>自旋锁</em>,并代码实现<em>自旋锁</em>和互斥锁的性能对比,以及利用C++11实现<em>自旋锁</em>。 一:<em>自旋锁</em>(spin lock)     <em>自旋锁</em>是一种用于保护多线程共享资源的锁,与一般互斥锁(<em>mutex</em>)不同之处在于当<em>自旋锁</em>尝试获取锁时以忙
自旋锁(spin lock)与互斥锁(mutex)的比较
<em>自旋锁</em>是一种非阻塞锁,也就是说,如果某线程需要获取<em>自旋锁</em>,但该锁已经被其他线程占用时,该线程不会被挂起,而是在不断的消耗CPU的时间,不停的试图获取<em>自旋锁</em>。互斥量是阻塞锁,当某线程无法获取互斥量时,该线程会被直接挂起,该线程不再消耗CPU时间,当其他线程释放互斥量后,操作系统会激活那个被挂起的线程,让其投入运行。两种锁适用于不同场景:如果是多核处理器,如果预计线程等待锁的时间很短,短到比线程两次上...
linux kernel 信号量、互斥锁、自旋锁
1.信号量1.1 概念信号量又称为信号灯(semaphore),本质上信号量是一个计数器,它用来记录对某个资源(如共享内存)的存取状况。一般说来,为了获得共享资源,进程需要执行下列操作:    (1) 测试控制该资源的信号量。    (2) 若此信号量的值为正,则允许进行使用该资源。进程将信号量减1。    (3) 若此信号量为0,则该资源目前不可用,进程进入睡眠状态,直至信号量值大于0
自旋锁,Mutex和信号量的使用
原帖地址:http://blog.csdn.net/lhf_tiger/article/details/7203299   转载一下    Mutex是一把钥匙,一个人拿了就可进入一个房间,出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问,保证这段代码不会被并行的运行。   Semaphore是一件可以容纳N人的房间,如果人不
自旋锁替代互斥锁使用场景
<em>自旋锁</em>替代互斥锁使用场景
常见锁的区别及适用场景
互斥锁:<em>mutex</em>,用于保证在任何时刻,都只能有一个线程访问该对象。当获取锁操作失败时,线程会进入睡眠,等待锁释放时被唤醒<em>自旋锁</em>:spinlock,在任何时刻同样只能有一个线程访问对象。但是当获取锁操作失败时,不会进入睡眠,而是会在原地自旋,直到锁被释放。这样节省了线程从睡眠状态到被唤醒期间的消耗,在加锁时间短暂的环境下会极大的提高效率。但如果加锁时间过长,则会非常浪费CPU资源读写锁:rwlock
自旋锁互斥锁使用注意区别
<em>自旋锁</em>:互斥锁:1.<em>自旋锁</em>不会睡眠,互斥锁会有睡眠,因此<em>自旋锁</em>效率高于互斥锁。2.由于一直查询,所以<em>自旋锁</em>一直占用cpu,互斥锁不会,<em>自旋锁</em>导致cpu使用效率低3.<em>自旋锁</em>容易造成死锁 互斥锁和<em>自旋锁</em>的区别https://blog.csdn.net/susidian/article/details/510688581、<em>自旋锁</em>一直占用CPU,他在未获得锁的情况下,一直运行--自旋,所以占用着CPU,...
Java CAS自旋锁
悲观者与乐观者的做事方式完全不一样,悲观者的人生观是一件事情我必须要百分之百完全控制才会去做,否则就认为这件事情一定会出问题;而乐观者的人生观则相反,凡事不管最终结果如何,他都会先尝试去做,大不了最后不成功。这就是悲观锁与乐观锁的区别,悲观锁会把整个对象加锁占为自有后才去做操作,乐观锁不获取锁直接做操作,然后通过一定检测手段决定是否更新数据。这一节将对乐观锁进行深入探讨。 上节讨论的Sync
C++11实现自旋锁
http://blog.poxiao.me/p/spinlock-implementation-in-cpp11/ <em>自旋锁</em>(Spinlock) <em>自旋锁</em>是一种用于保护多线程共享资源的锁,与一般的互斥锁(<em>mutex</em>)不同之处在于当<em>自旋锁</em>尝试获取锁的所有权时会以忙等待(busy waiting)的形式不断的循环检查锁是否可用。在多处理器环境中对持有锁时间较短的程序来说使用<em>自旋锁</em>代替一般的互斥锁往
Linux中互斥锁、读写锁、自旋锁的使用
Linux中常见的锁主要有: 互斥锁、读写锁、<em>自旋锁</em>。这三种锁的使用以及区别将在下面一步步深入了解。 1 互斥锁 1.1 互斥锁的作用 互斥锁(也称互斥量)可以用于保护关键代码段,以确保其独占式的访问,和有点像一个二进制信号量。当进入关键代码段时,我们需要获得互斥锁并将其加锁,这等加于二进制信号量的P操作;当离开关键代码段时,我们需要对互斥锁解锁,以唤醒其他等待该互斥锁的线程,这等价于二进...
内核中各种同步机制(自旋锁大内核锁顺序锁等)
原子操作 <em>自旋锁</em> 读写<em>自旋锁</em> 信号量 读写信号量 互斥量 完成变量 大内核锁 顺序锁 禁止抢占 顺序和屏障 如何选择 原子操作  原子操作是由编译器来保证的,保证一个线程对数据的操作不会被其他线程打断。  <em>自旋锁</em>  原子操作只能用于临界区只有一个变量的情况,实际应用中,临界区的情况要复杂的多。对于复杂的临界区,Linux 内核提供了多种方法,<em>自旋锁</em>就是其一。<em>自旋锁</em>的特点就是当一个线程获取了锁之
C++互斥量、原子锁、自旋锁等比较
现象: (1)单线程无锁速度最快,但应用场合受限; (2)多线程无锁速度第二快,但结果不对,未保护临界代码段; (3)多线程原子锁第三快,且结果正确; (4)多线程互斥量较慢,慢与原子锁近10倍,结果正确; (5)多线程<em>自旋锁</em>最慢,慢与原子锁30倍,结果正确。 结论:原子锁速度最快,互斥量和<em>自旋锁</em>都用保护多线程共享资源。        <em>自旋锁</em>是一种非阻塞锁,也就是说,如果某线程需要获...
互斥锁,自旋锁与自适应自旋锁
线程安全与锁的优化互斥锁:从 实现原理上来讲,Mutex属于sleep-waiting类型的锁。例如在一个双核的机器上有两个线程(线程A和线程B),它们分别运行在Core0和 Core1上。假设线程A想要通过pthread_<em>mutex</em>_lock操作去得到一个临界区的锁,而此时这个锁正被线程B所持有,那么线程A就会被阻塞 (blocking),Core0 会在此时进行上下文切换(Context Swi
Linux内核学习笔记(十一)内核同步方法(自旋锁,信号量,互斥锁,完成变量,顺序锁,禁止抢占)
原子操作 Linux内核提供了多种同步机制,这些机制本质上都是通过原子操作来实现的。原子操作可以保证指令以原子方式执行,不会被中途打断(中断也不会打断一个指令,处理器只有在当前指令完成后才会去处理中断)。内核提供了两套原子操作的接口,一套用于整数原子操作,一套用于进行位原子操作。这些接口的实现是和架构相关的,Linux系统支持的所有架构都实现了这些接口。大部分架构为简单的算术运算提供了原子版本的...
原子操作 信号量 自旋锁 互斥锁
原子操作 信号量 <em>自旋锁</em> 互斥锁
互斥锁 自旋锁 读写锁的区别
互斥锁:共享资源的使用是互斥的,即一个线程获得资源的使用权后就会将该资源加锁,使用完后会将其解锁,如果在使用过程中有其他线程想要获取该资源的锁,那么它就会被阻塞陷入睡眠状态,直到该资源被解锁才会被唤醒,如果被阻塞的线程不止一个,那么它们都会被唤醒,但是获得资源使用权的是第一个被唤醒的线程,其它线程又陷入沉睡. 递归锁:同一个线程可以多次获得该资源锁,别的线程必须等该线程释放所有次数的...
互斥锁vs共享锁vs自旋锁
共享锁:如果事务T对数据A加上共享锁后,则其他事务只能对A再加共享锁,不能加排他锁,直到已释放所有共享锁。获准共享锁的事务只能读数据,不能修改数据。 排他锁:如果事务T对数据A加上排他锁后,则其他事务不能再对A加任任何类型的锁,直到在事务的末尾将资源上的锁释放为止。获准排他锁的事务既能读数据,又能修改数据。 linux <em>自旋锁</em>: 进程运行是会锁住自己所拥有的资源,不让其他进程来破坏(即自己锁住...
各类锁(互斥锁,自旋锁,读写锁,乐观锁,悲观锁,死锁)
互斥锁: 当有一个线程要访问共享资源(临界资源)之前会对线程访问的这段代码(临界区)进行加锁。如果在加锁之后没释放锁之前其他线程要对临界资源进行访问,则这些线程会被阻塞睡眠,直到解锁,如果解锁时有一个或者多个线程阻塞,那么这些锁上的线程就会变成就绪状态,然后第一个变为就绪状态的线程就会获取资源的使用权,并且再次加锁,其他线程继续阻塞等待。 读写锁: 也叫做共享互斥锁,读模式共享,写模式互斥。有点像...
自旋锁和信号量区别
在驱动程序中,当多个线程同时访问相同的资源时(驱动程序中的全局变量是一种典型的共享资源),可能会引发"竞态",因此我们必须对共享资源进行并发控制。Linux内核中解决并发控制的最常用方法是<em>自旋锁</em>与信号量(绝大多数时候作为互斥锁使用)。  <em>自旋锁</em>与信号量"类似而不类",类似说的是它们功能上的相似性,"不类"指代它们在本质和实现机理上完全不一样,不属于一类。  <em>自旋锁</em>不会引起调用者睡眠,如果<em>自旋锁</em>已经被别的执行单元保持,调用者就一直循环查看是否该<em>自旋锁</em>的保持者已经释放了锁,"自旋"就是"在原地打转"。而信号量则
linux驱动中的互斥途径三:自旋锁
介绍互斥机制中的互斥锁
自旋锁、信号量、互斥锁的介绍和区别
本文转载自:http://blog.csdn.net/u012719256/article/details/52670098 信号量一般又叫做信号灯,协调不同进程间的数据对象的,本质上是一个计数器,记录对某个资源(共享内存)的存取情况。 从定义来看,信号量底层使用到了spin lock的锁定机制,这个spinlock主要用来确保对count成员的原子操作 使用的大致方式: 1)
守护进程、互斥锁、列队的使用案例
守护进程 如果子进程开启了守护模式,那么主进程运行完后立即干死子进程 from multiprocessing import Process import time def foo(): print(123) time.sleep(1) print(&amp;amp;amp;amp;amp;quot;end123&amp;amp;amp;amp;amp;quot;) def bar(): print(456) time.sleep(3) ...
驱动编写--中断,互斥和自旋锁
中断: 一般中断: if (request_irq(BUTTON_IRQ, button_interrupt, 0, "button", NULL))    { printk(KERN_ERR "button.c: Can't allocate irq %d\n", button_irq);         return -EBUSY;     } /* 参数1:参数一:
关于spinlock和mutex的性能差异
转自:http://www.cnblogs.com/diyunpeng/archive/2011/06/07/2074059.html 锁机制(lock) 是多线程编程中最常用的同步机制,用来对多线程间共享的临界区(Critical Section) 进行保护。 Pthreads提供了多种锁机制,常见的有: 1) Mutex(互斥量):pthread_<em>mutex</em>_*** 2) Sp
用户态自旋锁、读写自旋锁及互斥锁
1、<em>自旋锁</em> <em>自旋锁</em>最多可能被一个可执行线程所持有。一个被征用的<em>自旋锁</em>使得请求它的线程在等待锁重新可用时自旋(特别浪费处理器时间)。所以<em>自旋锁</em>不应该被长时间持有。 <em>自旋锁</em>是不可递归的! (1)<em>自旋锁</em>相关函数        用户态的<em>自旋锁</em>相关函数包含在头文件中。        相关函数:        int pthread_spin_destroy(pthread
iOS 开发中的八种锁(Lock)
锁之前的性能的图表: lock_benchmark.png 发现除了@synchronized 用过,其他的都陌生的很,可以说完全不知道啥玩意儿~ 于是怀着惭愧的心情赶紧把这些锁学习了下,废话不多说,我们开始: 锁 是什么意思? 我们在使用多线程的时候多个线程可能会访问同一块资源,这样就很容易引发数据错乱和数据安全等问题,这时候就需要我们保证每次只有一个线程访问这一块
linux内核锁机制实例代码-不可睡眠锁之自旋锁之二
spinlock.h DEFINE_SPINLOCK 在kernel里面找到一个使用他的例子 获取锁 static inline void spin_lock(spinlock_t *lock) { raw_spin_lock(&lock->rlock); } static DEFINE_SPINLOCK(threads_lock); struct our_d
深入理解Linux用户空间的锁机制
1.         缘起      随着SMP(Symmetrical Multi-Processing)架构的流行和epoll类系统调用对非阻塞fd监视的支持,高性能服务器端的开发已经能够实现CPU计算和IO的分离。为了充分发挥CPU的计算能力,服务器端的设计必须要尽量减少线程切换。引起线程切换最重要的原因之一就是对<em>mutex</em>和semaphor等锁的使用。本文从计算机体系架构、操作系统的
Linux内核中锁机制之原子操作、自旋锁
很多人会问这样的问题,Linux内核中提供了各式各样的同步锁机制到底有何作用?追根到底其实是由于操作系统中存在多进程对共享资源的并发访问,从而引起了进程间的竞态。这其中包括了我们所熟知的SMP系统,多核间的相互竞争资源,单CPU之间的相互竞争,中断和进程间的相互抢占等诸多问题。 通常情况下,如图1所示,对于一段程序,我们的理想是总是美好的,希望它能够这样执行:进程1先对临界区完成操作,然后进
互斥锁,同步锁,临界区,互斥量,信号量,自旋锁之间联系
互斥锁和互斥量在我的理解里没啥区别,不同叫法。广义上讲可以值所有实现互斥作用的同步机制。狭义上讲指的就是<em>mutex</em>这种特定的二元锁机制。互斥锁的作用就是互斥,mutual exclusive,是用来保护临界区(critical section)的。所谓临界区就是代码的一个区间,如果两个线程同时执行就有可能出问题,所以需要互斥锁来保护。信号量(semaphore)是一种更高级的同步机制,<em>mutex</em>可...
C# 并行编程 之 自旋锁的使用
基本信息 如果持有锁的时间非常短,而且锁的粒度很精细,那么使用<em>自旋锁</em>会获得更好的性能。有时候,Monitor互斥锁的开销还是相当大的。但SpinLock 的与Monitor的使用形式还是基本类似的。
[Linux]互斥机制(中断屏蔽、原子操作、自旋锁、信号量)
基本概念 临界区 互斥机制 用户空间和内核空间 互斥机制 中断屏蔽、原子操作、<em>自旋锁</em>、信号量
可重入锁(递归锁)&&互斥锁属性设置
前言: 上一次刷博客的时候,看到了<em>自旋锁</em>,通过学习Linux内核,对<em>自旋锁</em>有了一定的了解。在学习的过程中看到这么一句话——<em>自旋锁</em>是不可递归的。<em>自旋锁</em>不可递归,难道有可以递归的锁?带着这个问题,我们来看看什么是可以递归的锁。   回顾进程/线程同步方法 最常见的进程/线程的同步方法有互斥锁(或称互斥量Mutex),读写锁(rdlock),条件变量(cond),信号量(Semophore)等。...
几种自旋锁SpinLock,TicketLock,CLHLock,以及可重入实现要点,非阻塞锁实现要点
最核心的东西:synchronization state,同步状态:指示当前线程是否可以proceed还是需要wait的状态。 1.普通SpinLock (支持可重入的版本) class SpinLock { private AtomicReference owner = new AtomicReference(); // use thread itself as synchronizat
中断处理函数中自旋锁的应用
中断处理函数中,在获取锁之前,必须先禁止本地中断。否则,持有锁的内核代码会被中断处理程序打断,接着试图去争用这个已经被持有的<em>自旋锁</em>。这样的结果是,中断处理函数自旋,等待该锁重新可用,但是锁的持有者在该中断处理程序执行完毕之前不可能运行,这就成为了双重请求死锁。注意,需要关闭的只是当前处理器上的中断。因为中断发生在不同的处理器上,即使中断处理程序在同一锁上自旋,也不会妨碍锁的持有者(在不同处理器上)
多线程的同步与互斥(互斥锁、条件变量、读写锁、自旋锁、信号量)
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统,即同时有大量可调度实体在运行。在多任务操作系统中,同时运行的多个任务可能: 都需要访问/使用同一种资源; 多个任务之间有依赖关系,某个任务的运行依赖于另一个任务。 【同步】:   是指散步在不同任务之间的若干程序片断,它们的运行必须严格按照规定的某种先后次序来运行,这种先后次序依赖于要完成的特定的任务。最基本的场景就是:两个或两个以...
互斥锁、读写锁 、 自旋锁和RCU锁
基础知识思考整理http://blog.csdn.net/aganlengzi/article/details/50996227 互斥锁 <em>mutex</em>:在访问共享资源之前对进行加锁操作,在访问完成之后进行解锁操作。 加锁后,任何其他试图再次加锁的线程会被阻塞,直到当前进程解锁。 如果解锁时有一个以上的线程阻塞,那么所有该锁上的线程都被编程就绪状态, 第一个变为就绪状态的线程又执行加锁操作,那么其
进程间通信学习笔记-互斥锁 && 读写锁
第七章 互斥锁和条件变量 互斥锁是用于保护临界区的,实际上是保护在临界区中被操纵的数据,保护多个线程或者多个进程的共享数据。 #include int pthread_<em>mutex</em>_lock(pthread_<em>mutex</em>_t *mptr); int pthread_<em>mutex</em>_trylock(pthread_<em>mutex</em>_t *mptr); int pthread_<em>mutex</em>_unlock(pt
pthread的互斥量和自旋锁
一、<em>自旋锁</em>与互斥量的区别 在多处理器环境中,<em>自旋锁</em>最多只能被一个可执行线程持有。如果一个可执行线程试图获得一个被争用(已经被持有的)<em>自旋锁</em>,那么该线程就会一直进行忙等待,自旋,也就是空转,等待锁重新可用。如果锁未被争用,请求锁的执行线程便立刻得到它,继续执行。一个被争用的<em>自旋锁</em>使得请求它的线程在等待锁重新可用时自旋,特别的浪费CPU时间,所以<em>自旋锁</em>不应该被长时间的持有。实际上,这就是<em>自旋锁</em>的设计
并发编程--CAS自旋锁
在前两篇博客中我们介绍了并发编程--volatile应用与原理和并发编程--synchronized的实现原理(二),接下来我们介绍一下CAS<em>自旋锁</em>相关的知识。一、<em>自旋锁</em>提出的背景由于在多处理器系统环境中有些资源因为其有限性,有时需要互斥访问(mutual exclusion),这时会引入锁的机制,只有获取了锁的进程才能获取资源访问。即是每次只能有且只有一个进程能获取锁,才能进入自己的临界区,同一
多线程之mutex、semaphore区别
semaphore范围更广,<em>mutex</em>是semaphore其中的一种使用。<em>mutex</em>是二维变量,锁住和解锁,semaphore可能会有多维的属性,可以看出semaphore是包括<em>mutex</em>的。而其中大部分说的lock和<em>mutex</em>其实是同一个概念,可以先移步看一下wiki解释。Synchronization  其中区别是<em>mutex</em>只允许一个一个线程或者一个进程访问被修饰的内容,可见其既可以用于进程
JAVA多线程之——自旋锁、CLH、MCS
<em>自旋锁</em>学习了解<em>自旋锁</em>之前先回顾一下互斥锁 互斥锁 线程在获取互斥锁的时候,如果发现锁已经被其它线程占有,那么线程就会惊醒休眠,然后在适当的时机(比如唤醒)在获取锁。 <em>自旋锁</em> 那么<em>自旋锁</em>顾名思义就是“自旋”。就是当一个线程在尝试获取锁失败之后,线程不会休眠或者挂起,而是一直在循环检测锁是否被其它线程释放。 区别 互斥锁就是开始开销要大于<em>自旋锁</em>。临界区持锁时间的大小并不会对互斥锁的开销造成影
SMP 系统下的锁互斥
  SMP 系统下的锁互斥UP系统下的互斥         在单处理器(unique process)系统上,任何允许多个控制路径(多个线程或者多个进程),都会有竞争条件的发生。1)  短期互斥:在单处理器中,如果系统不允许在内核态抢占,那么就不会出现互斥的问题,只有允许在内核抢占时,也就是分时间片时,才出现互斥的情况。这主要用于修改一个内核共享的数据结构。实现的方法:禁止抢占2)  和中断处理程序的互斥:进程和中断处理程序(也就是相当于出现两个控制路径)同时访问共享资源时会发生互斥。实现的方法:关闭中断
Java中线程同步锁和互斥锁有啥区别?看完你还是一脸懵逼?
首先不要钻概念牛角尖,这样没意义。 也许java语法层面包装成了sycnchronized或者明确的XXXLock,但是底层都是一样的。无非就是哪种写起来方便而已。 锁就是锁而已,避免多个线程对同一个共享的数据并发修改带来的数据混乱。 锁要解决的大概就只有这4个问题: &quot;谁拿到了锁&quot; 这个信息存哪里(可以是当前class,当前instance的markword,还可以是某个具体的Lock的...
自旋锁与信号量的区别是什么? 分别在什么场景下使用?
<em>自旋锁</em>与信号量作为同步机制,都是用来保护临界区的,但是它们的工作方式完全不一样。 <em>自旋锁</em>只有两种状态,即LOCKED与UNLOCKED。 而信号量既可以作为互斥锁来使用(此时具有0和1两种状态),也可以作为资源计数器来使用(此时为正整数,具有不同的值,例如:0,1,2,...)进程在获取<em>自旋锁</em>时,会持续地查询锁的状态(读改写的原子操作),若未获取到锁则CPU会处于一直忙等待状态,这正是“自
MUTANT与MUTEX有什么区别
RT:rnMUTANT与MUTEX有<em>什么区别</em>?rn甚至在内核中它用的是一个数据结构
重入锁和自旋锁(公平锁及非公平锁)
公平锁,就是很公平,在并发环境中,每个线程在获取锁时会先查看此锁维护的等待队列,如果为空,或者当前线程线程是等待队列的第一个,就占有锁,否则就会加入到等待队列中,以后会按照FIFO的规则从队列中取到自己 非公平锁比较粗鲁,上来就直接尝试占有锁,如果尝试失败,就再采用类似公平锁那种方式 前言重入锁(ReentrantLock)是一种递归无阻塞的同步机制。 重入锁,也叫做递归锁,指的是同一线程
尝试用c11的条件变量和mutex写了一个读写锁
大家多多指正哈~ https://github.com/fishCi/c11/blob/master/rwlock.cpp #include #include #include #include #include using namespace std; class rwlock { private: <em>mutex</em> _lock; condition_v
临界区、互斥锁、自旋锁、信号量、事件
五种进程或线程同步互斥的控制方法 临界区: 通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 互斥量/互斥锁: 为协调共同对一个共享资源的单独访问而设计的;因为进入内核模式,所以性能比临界区差;跨进程。 <em>自旋锁</em>: 一种互斥锁的实现,等待的时候会占用CPU,通过循环判断锁是否被释放,因此比较快速,但是一直占用CPU时间。 信号量: 为控制一个具有有限数量用户资源而设计,互...
Linux中临界区、互斥量、信号量、自旋锁和事件的区别与联系
Linux中四种进程或线程同步互斥的控制方法 1、临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 2、互斥量:为协调共同对一个共享资源的单独访问而设计的,互斥对象只有一个。 3、信号量:为控制一个具有有限数量用户资源而设计,只能在进程上下文中使用,适合长时间访问共享资源的情况 4、<em>自旋锁</em>:适合短时间访问共享资源的情况,如果锁被长时间持有,等待线程会消耗...
CAS锁与MUTEX锁性能测试
C源码: #include #include #include #include #define lock(lkp) do{ \ while(!__sync_bool_compare_and_swap(lkp, 0, 1)){ \ usleep(1000); \ } \ }while(0) #define unlock(lkp) do{
十、Redis实现互斥锁
SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX] EX seconds − 设置指定的到期时间(以秒为单位)。 PX milliseconds - 设置指定的到期时间(以毫秒为单位)。 NX - 仅在键不存在时设置键。 XX - 只有在键已存在时才设置。    实现互斥锁需要用到以上命令,比如: //设置“锁” if(redis...
arm架构的独占读写指令ldrex和strex的使用详解(原子操作和自旋锁实现的基本原理)
LDREX 和 STREX 独占加载和存储寄存器。 语法 LDREX{cond} Rt, [Rn {, #offset}] STREX{cond} Rd, Rt, [Rn {, #offset}] LDREXB{cond} Rt, [Rn] 字节加载 STREXB{cond} Rd, Rt, [Rn] 字节存
linux下内核态锁与用户态锁详细介绍
1 内核态下锁 1.1 spinlock_t spinlock_t成为<em>自旋锁</em>,它用在临界区代码非常少的情况下。<em>自旋锁</em>不会引起调用者睡眠,如果<em>自旋锁</em>已经被别的执行单元保持,调用者就一直循环在那里看是否该<em>自旋锁</em>的保持者已经释放了锁,如果释放了该锁,请求锁的调用者可以立即得到它,继续执行。<em>自旋锁</em>可用于中断服务程序之中。 初始化 spinlock_t使用前需进行初始化,<em>自旋锁</em>的初始化有两种方式: ...
lock Mutex Monitor 之间的区别与详解, .net 多线程 同步异步操作,锁
Framework为我们提供了三个加锁的机制,分别是Monitor类、Lock关 键字和Mutex类。   总体而言,lock和monitor可以锁定对象,也可以锁定函数;而<em>mutex</em>一般用于锁定函数,并保证不同线程间同步调用函数,而不会受线程优先级影响。使用lock和monitor对象锁定对象时(即在对象外部锁定,或者在对象中的函数被调用的地方锁定对象),可以保证该对象一次只被一个线程
java 并发信号量和普通锁的区别
信号量:java.util.concurrent.Semaphore 使用方法和synchronized关键字类似,区别在于前者可以同时允许规定数量的线程执行,而后者对于不同的线程是互斥的,Semaphore 可以提供公平和不公平锁synchronized关键字同lock的区别: lock在性能上较好,切支持公平锁和非公平锁 对于wait()方法,lock提供了condition可以实现和sy
java基础——自旋锁
参考:https://blog.csdn.net/sunp823/article/details/49886051 https://www.cnblogs.com/wade-luffy/p/5969418.html 一、<em>自旋锁</em>的概念   普通的锁,是线程A拥有了锁之后,线程B如果此时想要获得A的锁,则需要等待进入阻塞态,等待线程A 释放锁之后,然后从阻塞态进入唤醒态去获得A释放的锁;然后线程...
探讨iOS开发中各种锁
摘要 平常项目开发中需要手动加锁的地方少之又少,而且一般是简单粗暴使用@synchronized搞定,不过打算封装框架时就会发现远不满足。本文的目的是希望站在iOS开发中锁的使用之上的层面分析,探讨各种加锁方式的大致实现原理以及它们之间的区别和性能对比。由于加锁必然涉及到多线程相关知识,所以本文涉猎的知识点可能较多,本着相互学习探讨的心态,希望大家多多指正。 首先借鉴一张ibireme各种锁性
详解信号量和互斥锁之间的区别和联系
一:信号量与互斥锁之间的区别: (1):互斥量用于线程的互斥,信号线用于线程的同步。这是互斥量和信号量的根本区别,也就是互斥和同步之间的区别。 (2):互斥量值只能为0/1,信号量值可以为非负整数。 也就是说,一个互斥量只能用于一个资源的互斥访问,它不能实现多个资源的多线程互斥问题。 信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是,也可以完成一个资源的互斥访问。信号量...
线程同步(4):linux各种锁详解
在linux内核中,有很多同步机制。比较经典的有原子操作、spin_lock(忙等待的锁)、<em>mutex</em>(互斥锁)、semaphore(信号量)等。并且它们几乎都有对应的rw_XXX(读写锁),以便在能够区分读与写的情况下,让读操作相互不互斥(读写、写写依然互斥)。而seqlock和rcu应该可以不算在经典之列,它们是两种比较有意思的同步机制。 atomic(原子操作): 所谓原子操作,就是该操
自旋锁死锁与优先级反转
最近在看马忠梅老师的cortex微控制器教程和robert love的linux内核设计与实现有点小心得,特与论坛朋友们分享,我现在在学习linux,看到<em>自旋锁</em>那里时,love写到<em>自旋锁</em>可以用在中断程序中,(但不能用信号量,信号量会睡眠),在中断中使用<em>自旋锁</em>的时候一定要禁止本地中断,否则中断(肯定是高级中断)可能会打断正在持有<em>自旋锁</em>的中断程序,可能会视图争用这个已经被持有的锁。因为是<em>自旋锁</em>,所以这
聊聊高并发(六)实现几种自旋锁(一)
在聊聊高并发(五)理解缓存一致性协议以及对并发编程的影响 我们了解了处理器缓存一致性协议的原理,并且提到了它对并发编程的影响,“多个线程对同一个变量一直使用CAS操作,那么会有大量修改操作,从而产生大量的缓存一致性流量,因为每一次CAS操作都会发出广播通知其他处理器,从而影响程序的性能。” 这一篇我们通过两种实现<em>自旋锁</em>的方式来看一下不同的编程方式带来的程序性能的变化。 先理解一
为什么有了互斥锁还要条件变量(二者的不同)
一。互斥量和条件变量简介 互斥量(<em>mutex</em>)从本质上说是一把锁,在访问共享资源前对互斥量进行加锁,在访问完成后释放互斥量上的锁。对互斥量进行加锁以后,任何其他试图再次对互斥锁加锁的线程将会阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞,所有在该互斥锁上的阻塞线程都会变成可运行状态,第一个变为运行状态的线程可以对互斥锁加锁,其他线程将会看到互斥锁依然被锁住,只能回去再次
不可重入锁/自旋锁、可重入锁
转载自:http://blog.csdn.net/soonfly/article/details/70918802 锁分为可重入锁和不可重入锁。  可重入和不可重入的概念是这样的:当一个线程获得了当前实例的锁,并进入方法A,这个线程在没有释放这把锁的时候,能否再次进入方法A呢? 可重入锁:可以再次进入方法A,就是说在释放锁前此线程可以再次进入方法A(方法A递归)。不可重入锁(<em>自旋锁</em>)
OC自旋锁的简单使用
#import "ViewController.h" @interface ViewController () @property(atomic,copy)NSString *name; @end @implementation ViewController @synthesize name = _name; -(void)set
linux线程同步(4)-自旋锁
<em>自旋锁</em>与互斥量功能一样,唯一一点不同的就是互斥量阻塞后休眠让出cpu,而<em>自旋锁</em>阻塞后不会让出cpu,会一直忙等待,直到得到锁!!! <em>自旋锁</em>在用户态使用的比较少,在内核使用的比较多!<em>自旋锁</em>的使用场景:锁的持有时间比较短,或者说小于2次上下文切换的时间。 <em>自旋锁</em>在用户态的函数接口和互斥量一样,把pthread_<em>mutex</em>_xxx()中<em>mutex</em>换成spin,如:pthread_spin_init(
DelphiXE10.2.3实现线程安全访问数据和对象(二)——如何理解原子自旋锁
     基于《DelphiXE10.2.3实现线程安全访问数据和对象(一)——Delphi原子操作函数介绍》中的原子操作函数,我们再来逐渐理解和实现一个原子<em>自旋锁</em>。     “原子<em>自旋锁</em>”中的“自旋”其实就是一个读或写数据过程中的一个while循环,只不过while的条件是用原子操作函数来判断条件是否成立,不成立会一直循环自旋直到条件成立为止,看上去似乎会很消耗cpu资源,但其实我们可以灵活处理...
整理关于Windows自旋锁实现
结合前面从IRQ到IRQL(APIC版) 和Windows <em>自旋锁</em>分析(一)  可以知道HalBeginSystemInterrupt通过用IRQL做索引在HalpIRQLtoTPR数组中获取该IRQL对应的任务优先级, 用该优先级设置任务优先级寄存器TPR, 并把TPR中原先的任务优先级/16做为索引在HalpVectorToIRQL数组中获取对应的原先的IRQL然后返回。 观察K
Spin lock(自旋锁)与mutex 的区别
转载自:https://blog.csdn.net/kyokowl/article/details/6294341POSIX threads(简称Pthreads)是在多核平台上进行并行编程的一套常用的API。线程同步(Thread Synchronization)是并行编程中非常重要的通讯手段,其中最典型的应用就是用Pthreads提供的锁机制(lock)来对多个线程之间共 享的临界区(Crit...
Linux 内核中的并发--自旋锁
<em>自旋锁</em>(获取<em>自旋锁</em>->临界区->释放<em>自旋锁</em>) <em>自旋锁</em>的名称源于它的工作原理:尝试获取一个<em>自旋锁</em>,如果锁空闲就获取该<em>自旋锁</em>并继续向下执行;如果锁已被占用就循环检测该锁是否被释放(原地打转直到锁被释放) 只有在占用锁的时间极短的情况下使用;不能递归使用一个<em>自旋锁</em>(形成死锁);占用锁时不能使用可能引起进程调度的函数,如copy_xx_user()、kmalloc()、msleep()… <em>自旋锁</em>主要
Java锁机制 自旋锁(spinlock)剖析
Spinlock 介绍线程通过 busy-wait-loop 方式来获取锁, 任何时刻只有一个线程能够获得锁, 其它线程忙等待知道获得锁。应用场景spinlock 不会有线程状态切换,所以响应更快。使用spinlock时, 临界区要尽量短,不要有显示或隐式的系统调用。如读写文件等操作。 临界区:指的是一个访问共用资源(例如:共用设备或是共用存储器)的程序片段,当有线程进入临界区段时,其他线程或是进
C#多线程学习(九)lock,Monitor,Mutex的区别
lock和Monitor的区别 一、lock的底层本身是Monitor来实现的,所以Monitor可以实现lock的所有功能。 二、Monitor有TryEnter的功能,可以防止出现死锁的问题,lock没有。 Mutex和其他两者的区别 个人测试三个都是在限制线程之外的互斥,线程之内,都不限制,同一个线程如果被lock两次。是不会出现死锁的。所以Mutex本身可以实现lock和Mo
认真的讲一讲:自旋锁到底是什么
什么是<em>自旋锁</em>? <em>自旋锁</em>(spinlock):是指当一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环。 获取锁的线程一直处于活跃状态,但是并没有执行任何有效的任务,使用这种锁会造成busy-waiting。 Java如何实现<em>自旋锁</em>? 下面是个简单的例子: /** * Date: 2016年1月4日 下...
自旋锁、中断和进程切换
1、进程可以有多个,但linux内核只有一个,相当于所有进程的全局代码区和全局变量,进程有自己的进程空间(用户空间+内      核空间,2个空间都有自己的页表);中断上下文只有内核空间,不可阻塞,不可调度进程2、单cpu<em>自旋锁</em>:运行在临界区域代码时,不运行发生进程切换(即不能阻塞,相当于主动释放cpu),要独占cpu                           不允许spin_lock保...
Linux中自旋锁相关函数及使用
<em>自旋锁</em>是一种轻量级的锁定,只能用于临界区短的代码段内,否则会降低系统运行的效率。 <em>自旋锁</em>主要是针对SMP(多核)或单核CPU但内核可抢占的情况,对于单CPU且内核不抢占的系统,<em>自旋锁</em>会退化成空操作。 <em>自旋锁</em>涉及的函数: 1、spin_lock_irq() = spin_lock() + local_irq_disable()     2、spin_unlock_irq() = spin_u...
Java 并发与多线程规范(4) 自旋锁是可重入的吗?CAS与自旋锁的关系,CAS的ABA问题,以及乐观锁,悲观锁,互斥锁,读写锁的整理
CASCAS,<em>自旋锁</em>跟compare and set有关系,但是并不是CAS就是<em>自旋锁</em>。我们看一段代码:/* 不同线程检测最大值 */ AtomicLong largest = new AtomicLong(); long obsvValue = 0; /* 错误的方式,此更新不是原子性的 */ largest.set(Math.max
C++互斥锁 临界区 信号量 事件的区别总结
转自http://blog.csdn.net/anddy926/article/details/7828173四种进程或线程同步互斥的控制方法 1、临界区CriticalSection: 通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 2、互斥量Mutex: 为协调共同对一个共享资源的单独访问而设计的。 3、信号量Semaphore: 为控制一个具有有限数量用户资
python互斥锁、加锁、同步机制、异步通信知识总结
python互斥锁、加锁、同步机制、异步通信知识总结某个线程要共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进入写入操作,从而保证了多线程情况下数据的正确性。采用f_flag的方法效率低创建锁<em>mutex</em>=threading.Lock()锁定<em>mutex</em>.acquire([b...
boost锁使用总结
boost锁的概述: boost库中提供了<em>mutex</em>类与lock类,通过组合可以轻易的构建读写锁与互斥锁。       举个通俗的例子,如果共享资源是一个自动锁住的房间,互斥体是钥匙,进入房间必须取钥匙,离开房间应该还钥匙。这就对应着互斥体的lock(取钥匙)和unlock(还钥匙)。      动态分配内存存在类似的情况。如果忘记delete,会导致内存泄漏。它是如何解决的?在栈上分配对象
自旋锁公平性的三种实现
随着多核处理器的爆炸式增长,多线程同步访问共享内存的性能也成了计算机系统发展的关键。在《互斥锁与<em>自旋锁</em>》这篇文章中我们提到了互斥锁与<em>自旋锁</em>之间的区别以及各自的优点和适用场景。 普通<em>自旋锁</em>的实现 我们适用Java代码来实现一个简单的<em>自旋锁</em>: import java.util.concurrent.atomic.AtomicBoolean; public class Spinlock ...
线程与互斥锁(C++11中std::thread和std::mutex的用法)
线程 0 首先是曾经在MultiCMOS项目中用到的: #include &amp;lt;thread&amp;gt; //包含头文件 class IDataProcessUnit { protected: bool m_processing{ false }; //线程退出标识 std::thread m_thrProcess; //线程句柄 public: //数据处理流程在...
Linux下的互斥锁、自旋锁、读写锁浅谈
<em>自旋锁</em> 概念: 何谓<em>自旋锁</em>?它是为实现保护共享资源而提出一种锁机制。其实,<em>自旋锁</em>与互斥锁比较类似,它们都是为了解决对某项资源的互斥使用。在任何时刻最多只能有一个执行单元获得锁,即任何时刻只有一个线程访问对象。如果<em>自旋锁</em>已经被别的执行单元保持(资源被占用)调用者就一直循环在那里看是否该<em>自旋锁</em>的保持者已经释放了锁。<em>自旋锁</em>不会引起调用者睡眠,&quot;自旋&quot;一词就是因此而得名。 原理: 跟互斥锁一样,一...
自旋锁和自适应自旋锁
<em>自旋锁</em> 所谓自旋,就是指当有另外一个线程来竞争锁时,这个线程会在原地循环等待,而不是把该线程给阻塞,直到那个获得锁的线程释放锁之后,这个线程就可以马上获得锁的。锁在原地循环的时候,是会消耗cpu的,就相当于在执行一个啥也没有的for循环。 本来一个线程把锁释放之后,当前线程是能够获得锁的,但是假如这个时候有好几个线程都在竞争这个锁的话,那么有可能当前线程会获取不到锁,还得原地等待继续空循环消耗...
windows 多线程 之自旋锁(spinlock)
我的上一篇文章介绍了原子性的概念,那么多线程之中就要防止
自旋锁以及Java中的自旋锁的实现
什么是<em>自旋锁</em> 多线程中,对共享资源进行访问,为了防止并发引起的相关问题,通常都是引入锁的机制来处理并发问题。 获取到资源的线程A对这个资源加锁,其他线程比如B要访问这个资源首先要获得锁,而此时A持有这个资源的锁,只有等待线程A逻辑执行完,释放锁,这个时候B才能获取到资源的锁进而获取到该资源。 这个过程中,A一直持有着资源的锁,那么没有获取到锁的其他线程比如B怎么办?通常就会有两种方式: 1...
静态分配互斥量与动态分配互斥量的区别和实例分析
1)、动态分配互斥量: #include #include struct foo { int f_count; pthread_<em>mutex</em>_t f_lock; /* ... more stuff here ... */ }; struct foo * foo_alloc(void) /* allocate the object */ { struct
Java 可重入自旋锁简单实现
<em>自旋锁</em>特点:1. 轻量级操作,无需挂起线程2. 特别吃CPU,如果线程在临界区的操作比较耗时或者线程对临界区的竞争很激烈,那还是老老实实用普通的锁以下是Java的简单实现public class SpinLock implements Lock { /** * 锁持有线程, null表示锁未被任何线程持有 */ private final AtomicRefe...
Java多线程/并发10、不可重入锁/自旋锁、可重入锁
锁分为可重入锁和不可重入锁。 可重入和不可重入的概念是这样的:当一个线程获得了当前实例的锁,并进入方法A,这个线程在没有释放这把锁的时候,能否再次进入方法A呢? 可重入锁:可以再次进入方法A,就是说在释放锁前此线程可以再次进入方法A(方法A递归)。 不可重入锁(<em>自旋锁</em>):不可以再次进入方法A,也就是说获得锁进入方法A是此线程在释放锁钱唯一的一次进入方法A。 先举例来说明锁的可重入性:public
Objective-C中不同方式实现锁
为什么需要使用锁,当然熟悉多线程的你,自然不会对它觉得陌生。 那你在代码中是否很好的使用了锁的机制呢?你又知道几种实现锁的方法呢? 今天一起来探讨一下Objective-C中几种不同方式实现的锁,在这之前我们先构建一个测试用的类,假想它是我们的一个共享资源,method1与method2是互斥的,代码如下: 1 2 3 4
Linux内核源码之自旋锁的实现
1 Linux内核同步 Linux内核中有许多共享资源,这些共享资源是内核中进程都有机会访问到的。内核对其中一些共享资源的访问是独占的,因此需要提供机制对共享资源进行保护,确保任意时刻只有一个进程在访问共享资源。<em>自旋锁</em>就是一种共享资源保护机制,确保同一时刻只有一个进程能访问到共享资源。 2 普通<em>自旋锁</em> 内核中提供的普通<em>自旋锁</em>API为spin_lock()何spin_unlock(),
Window驱动的同步机制
转载请标明是引用于 http://blog.csdn.net/chenyujing1234  欢迎大家拍砖!    参考书籍:> 1、中断请求级 在Windows的时候,设计者将中断请求分别划分为软件中断和硬件中断,并将这些中断都映射成不同级别的中断请求级(IRQL)。 同步处理机制很大程序上依赖于中断请求级,本节对中断请求级做介绍。 1、1 中断请求(I
JVM源码研读:Java 中自旋锁的实现
Java中初始是使用<em>mutex</em>互斥锁,因为互斥锁是会线程等待挂起,而对获取锁后的操作时间比较短暂的应用场景来说,这样的锁会让竞争锁的线程不停的park,unpark 的操作,这样的系统的调用性能是非常糟糕的,为了提高锁的性能,java 在6 默认使用了<em>自旋锁</em>。   在Linux中本身就已经提供了<em>自旋锁</em>的系统调用,在glibc-2.9中就有它的比较简单的实现方法   int pthread...
linux内核自旋锁总结
1、<em>自旋锁</em>实现: <em>自旋锁</em>是一个互斥设备,它只有两个值:“锁定”和“解锁”。它通常实现为某个整数值中的某个位。希望获得某个特定锁得代码测试相关的位。如果锁可用,则“锁定”被设置,而代码继续进入临界区;相反,如果锁被其他人获得,则代码进入忙循环(而不是休眠,这也是<em>自旋锁</em>和一般锁的区别)并重复检查这个锁,直到该锁可用为止,这就是自旋的过程。 “测试并设置位”的操作必须是原子的,多线程并发获取锁时所做
线程同步机制(互斥量,读写锁,自旋锁,条件变量,屏障)
先知:      (1)线程是由进程创建而来,是cpu调度的最小单位。      (2)每个进程都有自己独立的地址空间,而进程中的多个线程共用进程的资源,他们只有自己独立的栈资源。 线程同步:      当多个控制线程共享相同的内存时,需要确保每个进程看到一致的数据视图。同一个数据如果被两个及以上的线程进行同时访问操作的时候,有可能就会造成数据不一致的现象。为了解决这个问题,线程不
强连通分量及缩点tarjan算法解析
强连通分量: 简言之 就是找环(每条边只走一次,两两可达) 孤立的一个点也是一个连通分量   使用tarjan算法 在嵌套的多个环中优先得到最大环( 最小环就是每个孤立点)   定义: int Time, DFN[N], Low[N]; DFN[i]表示 遍历到 i 点时是第几次dfs Low[u] 表示 以u点为父节点的 子树 能连接到 [栈中] 最上端的点   int
课程设计做的AE+C#程序下载
GIS二次开发做的小程序,供大家参考。语言是VS08+AE9.3 相关下载链接:[url=//download.csdn.net/download/lwy_cl/1957128?utm_source=bbsseo]//download.csdn.net/download/lwy_cl/1957128?utm_source=bbsseo[/url]
c语言编写的最小二乘法下载
利用c语言编写的最小二乘法程序,可用于表格数据拟合 相关下载链接:[url=//download.csdn.net/download/lms870601/1996282?utm_source=bbsseo]//download.csdn.net/download/lms870601/1996282?utm_source=bbsseo[/url]
c++好好好c++好好好c++好好好c++下载
好好好好好好 好好好好好好c++ 好好好c++好好好c++ 好好好c++ 相关下载链接:[url=//download.csdn.net/download/xyx_2010/2102263?utm_source=bbsseo]//download.csdn.net/download/xyx_2010/2102263?utm_source=bbsseo[/url]
文章热词 设计制作学习 机器学习教程 Objective-C培训 交互设计视频教程 颜色模型
相关热词 mysql关联查询两次本表 native底部 react extjs glyph 图标 西班牙的人工智能有什么区别 产品经理培训都要什么区别
我们是很有底线的