同步的概念

1. 多线程开发可能遇到的问题

假设两个线程t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。

但是由于是多线程访问，有可能出现下面情况：

在num=0时，t1取得num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

from threading import Thread
import timeg_num = 0def test1():global g_numfor i in range(1000000):g_num += 1print("---test1---g_num=%d"%g_num)def test2():global g_numfor i in range(1000000):g_num += 1print("---test2---g_num=%d"%g_num)p1 = Thread(target=test1)
p1.start()# time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？p2 = Thread(target=test2)
p2.start()print("---g_num=%d---"%g_num)

运行结果(可能不一样，但是结果往往不是2000000)：

---g_num=284672---
---test1---g_num=1166544
---test2---g_num=1406832

取消屏蔽之后，再次运行结果如下：

---test1---g_num=1000000
---g_num=1041802---
---test2---g_num=2000000

问题产生的原因就是没有控制多个线程对同一资源的访问，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。

2. 什么是同步

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。

"同"字从字面上容易理解为一起动作

其实不是，"同"字应是指协同、协助、互相配合。

如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。

3. 解决问题的思路

对于本小节提出的那个计算错误的问题，可以通过线程同步来进行解决

思路，如下:

系统调用t1，然后获取到num的值为0，此时上一把锁，即不允许其他现在操作num
对num的值进行+1
解锁，此时num的值为1，其他的线程就可以使用num了，而且是num的值不是0而是1
同理其他线程在对num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以方便的处理锁定：

#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire([blocking])
#释放
mutex.release()

其中，锁定方法acquire可以有一个blocking参数。

如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有指定，那么默认为True）
如果设定blocking为False，则当前线程不会堵塞

使用互斥锁实现上面的例子的代码如下：

from threading import Thread, Lock
import timeg_num = 0def test1():global g_numfor i in range(1000000):#True表示堵塞 即如果这个锁在上锁之前已经被上锁了，那么这个线程会在这里一直等待到解锁为止 #False表示非堵塞，即不管本次调用能够成功上锁，都不会卡在这,而是继续执行下面的代码mutexFlag = mutex.acquire(True) if mutexFlag:g_num += 1mutex.release()print("---test1---g_num=%d"%g_num)def test2():global g_numfor i in range(1000000):mutexFlag = mutex.acquire(True) #True表示堵塞if mutexFlag:g_num += 1mutex.release()print("---test2---g_num=%d"%g_num)#创建一个互斥锁
#这个所默认是未上锁的状态
mutex = Lock()p1 = Thread(target=test1)
p1.start()p2 = Thread(target=test2)
p2.start()print("---g_num=%d---"%g_num)

运行结果：

---g_num=61866---
---test1---g_num=1861180
---test2---g_num=2000000

可以看到，加入互斥锁后，运行结果与预期相符。

上锁解锁过程

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。

每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。

线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。

总结

锁的好处：

确保了某段关键代码只能由一个线程从头到尾完整地执行

锁的坏处：

死锁

阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁

1. 死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子

#coding=utf-8
import threading
import timeclass MyThread1(threading.Thread):def run(self):if mutexA.acquire():print(self.name+'----do1---up----')time.sleep(1)if mutexB.acquire():print(self.name+'----do1---down----')mutexB.release()mutexA.release()class MyThread2(threading.Thread):def run(self):if mutexB.acquire():print(self.name+'----do2---up----')time.sleep(1)if mutexA.acquire():print(self.name+'----do2---down----')mutexA.release()mutexB.release()mutexA = threading.Lock()
mutexB = threading.Lock()if __name__ == '__main__':t1 = MyThread1()t2 = MyThread2()t1.start()t2.start()

运行结果：

2.死锁产生的原因

1. 系统资源的竞争

系统资源的竞争导致系统资源不足，以及资源分配不当，导致死锁。

2. 进程运行推进顺序不合适

进程在运行过程中，请求和释放资源的顺序不当，会导致死锁。

3.死锁的四个必要条件

互斥条件：一个资源每次只能被一个进程使用，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

请求与保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

不可剥夺条件:进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。

循环等待条件: 若干进程间形成首尾相接循环等待资源的关系

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

四、死锁的避免与预防

1. 死锁避免——银行家算法

2. 死锁预防

我们可以通过破坏死锁产生的4个必要条件来预防死锁，由于资源互斥是资源使用的固有特性是无法改变的。

破坏“不可剥夺”条件：一个进程不能获得所需要的全部资源时便处于等待状态，等待期间他占有的资源将被隐式的释放重新加入到系统的资源列表中，可以被其他的进程使用，而等待的进程只有重新获得自己原有的资源以及新申请的资源才可以重新启动，执行。
破坏”请求与保持条件“：第一种方法静态分配即每个进程在开始执行时就申请他所需要的全部资源。第二种是动态分配即每个进程在申请所需要的资源时他本身不占用系统资源。
破坏“循环等待”条件：采用资源有序分配其基本思想是将系统中的所有资源顺序编号，将紧缺的，稀少的采用较大的编号，在申请资源时必须按照编号的顺序进行，一个进程只有获得较小编号的进程才能申请较大编号的进程。

异步

同步调用就是你喊你朋友吃饭，你朋友在忙，你就一直在那等，等你朋友忙完了，你们一起去
异步调用就是你喊你朋友吃饭，你朋友说知道了，待会忙完去找你，你就去做别的了。

from multiprocessing import Pool
import time
import osdef test():print("---进程池中的进程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid()))for i in range(3):print("----%d---"%i)time.sleep(1)return "hahah"def test2(args):print("---callback func--pid=%d"%os.getpid())print("---callback func--args=%s"%args)pool = Pool(3)
pool.apply_async(func=test,callback=test2)time.sleep(5)print("----主进程-pid=%d----"%os.getpid())

运行结果：

---进程池中的进程---pid=9401,ppid=9400--
----0---
----1---
----2---
---callback func--pid=9400
---callback func--args=hahah
----主进程-pid=9400----

同步、互斥锁、死锁、异步相关推荐

python同步锁和互斥锁的区别_浅谈Python线程的同步互斥与死锁
这篇文章主要介绍了浅谈Python线程的同步互斥与死锁,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧线程间通信方法 1. 通信 ...
python线程死锁的原因,浅谈Python线程的同步互斥与死锁
线程间通信方法 1. 通信方法线程间使用全局变量进行通信 2. 共享资源争夺共享资源:多个进程或者线程都可以操作的资源称为共享资源.对共享资源的操作代码段称为临界区. 影响 : 对共享资源的无序操 ...
Linux c线程间的同步----互斥锁、条件变量、信号量
线程一个进程中的所有线程共享为进程分配的地址空间.所以进程地址空间中的代码段和数据段都是共享的. 如果定义一个函数在各个线程中都可以调用,定义一个全部变量,在各个线程中都可以访问到. 各线程共享资源 ...
线程互斥和同步-- 互斥锁
一. 线程分离我们一般创建的线程是可结合的,这个时候如果我们调用pthread_jion()去等待的话,这种等待的方式是阻塞式等待,如果主线程一直等待,主线程就无法做其他的事情了,所以应该使用线程分 ...
Python之线程的同步互斥与死锁
线程间通信方法 1. 通信方法线程间使用全局变量进行通信 2. 共享资源争夺共享资源:多个进程或者线程都可以操作的资源称为共享资源.对共享资源的操作代码段称为临界区. 影响 : 对 ...
线程同步(互斥锁、条件、读写锁、信号量)
参考:(四十三)线程--线程同步(互斥锁.读写锁.条件变量.信号量) 作者:FadeFarAway 发布时间:2017-01-17 21:25:28 网址:https://blog.csdn.net/ ...
6.2多线程-互斥锁/死锁
互斥锁-解决资源竞争问题方案1,两个线程其中一个上锁,执行完这个线程再执行下一个线程 #coding:utf-8 import threading import time# 创建一个全局变量 g_n ...
Linux多线程同步——互斥锁
互斥锁当多个线程对同一个资源进行访问的时候,为了这个资源的安全性,我们需要对这个资源进行锁定,规定同一时间只有一个资源能够获得该锁的钥匙,其它线程要获得该资源需要等待该线程互斥锁创建 pthrea ...
Linux多线程开发-线程同步-互斥锁pthread_mutex_t
1.互斥锁同一时刻只允许一个线程对临界区进行访问.POSIX库中用类型pthread_mutex_t来定义互斥锁,类型在pthreadtypes.h中定义. 2.如何声明一个互斥锁 #include ...
互斥锁、死锁、递归锁、信号量、Event
互斥锁死锁和递归锁 Semaphore信号量 Event事件互斥锁互斥锁也叫用户锁.同步锁. 在多进程/多线程程序中,当多个线程处理一个公共数据时,会有数据安全问题,唯一能保证数据安全的,就是通 ...

同步、互斥锁、死锁、异步

同步的概念

1. 多线程开发可能遇到的问题

2. 什么是同步

3. 解决问题的思路

互斥锁

上锁解锁过程

总结

死锁

1. 死锁

2.死锁产生的原因

3.死锁的四个必要条件

四、死锁的避免与预防

1. 死锁避免——银行家算法

2. 死锁预防

异步

同步、互斥锁、死锁、异步相关推荐

最新文章

热门文章

同步、互斥锁、死锁、异步

同步的概念

1. 多线程开发可能遇到的问题

2. 什么是同步

3. 解决问题的思路

互斥锁

上锁解锁过程

总结

死锁

1. 死锁

2.死锁产生的原因

3.死锁的四个必要条件

四、 死锁的避免与预防

1. 死锁避免——银行家算法

2. 死锁预防

异步

同步、互斥锁、死锁、异步相关推荐

最新文章

热门文章

四、死锁的避免与预防