在使用用的过程中需要导入threading模块的Lock类

使用锁:

  当多个线程几乎同时修改某一个共享数据的时候,需要进行同步控制
  线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互 斥锁。 
  互斥锁为资源引入一个状态:锁定/非锁定。
 

锁的语法

  创建锁、锁定锁、释放锁

from threading import Lock

# 创建锁
mutex = Lock()
# 获取锁(上锁)
mutex.acquire()
# 释放锁(解锁)
mutex.release()

  在锁定锁的过程中acquire()方法可以接受一个blocking参数,

    如果设定blocking为True,则当前线程会堵塞,直到获取到这个锁为止(如果没有 指定,那么默认为True)

    如果设定blocking为False,则当前线程不会堵塞

  上锁和解锁的过程(假设是多线程调度):

    这个锁一般是为共享资源服务的,即多个线程同时使用共享资源。这个锁同一时间只能有一个线程调度,其他线程阻塞,只有当前调度的线程释放这个锁,阻塞的线程才能调度。

  锁的优点:

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

  锁的缺点:

    组织了多线程的并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大的降低了;代码中可能存在多个锁,如果多个线程拥有多个锁,容易造成死锁。

  死锁的现象(实例):

# 死锁 两者都没有释放对方需要的锁,而释放的条件恰好是获取对方释放所需要的锁
# 线程1
class MyThread1(threading.Thread):
def __init__(self):
super().__init__() def run(self):
# 线程1获取A锁
if mutexA.acquire():
print(self.name+"-----do1---up-----")
sleep(1)
# 此时线程2获取了B锁,需要等待线程2释放B锁
if mutexB.acquire():
print(self.name + "-----do1---down-----")
mutexB.release()
mutexA.release() # 线程2
class MyThread2(threading.Thread):
def __init__(self):
super().__init__() def run(self):
# 线程2获取B锁
if mutexB.acquire():
print(self.name + "-----do2---up-----")
sleep(1)
# 此时线程1获取了A锁,需要等待线程1释放A锁
if mutexA.acquire():
print(self.name + "-----do2---down-----")
mutexA.release()
mutexB.release() mutexA = threading.Lock()
mutexB = threading.Lock() if __name__ == '__main__':
# 线程1和线程2同时执行
t1 = MyThread1()
t2 = MyThread2()
t1.start()
t2.start()

  避免死锁的方法:银行家算法

多进程与多线程比较及选择

是否采用多任务处理,取决于我们的任务类型

如果是计算密集型,需要大量的CPU资源进行运算,代码的运行效率至关重 要,这样的任务一般不使用多线程进行,因为频繁的任务调度会拖慢CPU的
运算。

如果是IO密集型,涉及到硬盘读写,网络读写等的任务,更多的时间在等待 IO操作完成,这一类任务可以放到多线程或多进程中来进行。

单线程、多线程、多进程(一起实现同一代码的时间)

# 单线程、多线程、多进程的使用及不同
# 简单的求和
def fib(x):
res = 0
for i in range(100000000):
res += i*x
return res # 阶乘
def fac(x):
if x < 2:
return 1
return x*fac(x-1) # 简单的求和
def sum(x):
res = 0
for i in range(50000000):
res += i*x
return res # 函数列表
funcs = [fib, fac, sum]
n = 100 class MyThread(threading.Thread):
def __init__(self, func, args, name=""):
super().__init__()
self.name = name
self.func = func
self.args = args
self.res = 0 def getResult(self):
return self.res def run(self):
print("starting ", self.name, " at: ", ctime())
self.res = self.func(self.args)
print(self.name, "finished at: ", ctime()) def main():
nfuncs = range(len(funcs)) print("单线程".center(30, "*"))
start = time()
for i in nfuncs:
print("start {} at: {}".format(funcs[i].__name__, ctime()))
start_task = time()
print(funcs[i](n))
end_task = time()
print("任务 耗时:", end_task-start_task)
print("{} finished at: {}".format(funcs[i].__name__, ctime())) end = time()
print("单线程运行时间:", end-start)
print("单线程结束:".center(30, "*")) print()
print("多线程".center(30, "*"))
start = time()
threads = []
for i in nfuncs:
# 一个线程绑定一个函数
t = MyThread(funcs[i], n, funcs[i].__name__)
threads.append(t) for i in nfuncs:
# 同时启动线程
threads[i].start() for i in nfuncs:
threads[i].join()
print(threads[i].getResult())
end = time()
print("多线程运行时间:", end-start)
print("多线程结束:".center(30, "*")) print()
print("多进程".center(30, "*"))
start = time()
process_list = []
for i in nfuncs:
# 一个进程绑定一个函数
t = Process(target=funcs[i], args=(n, ))
process_list.append(t) for i in nfuncs:
# 同时启动进程
process_list[i].start() for i in nfuncs:
process_list[i].join()
end = time()
print("多进程运行时间:", end - start)
print("多进程结束:".center(30, "*")) if __name__ == "__main__":
main()

python高级编程——锁的更多相关文章

  1. 第十章:Python高级编程-多线程、多进程和线程池编程

    第十章:Python高级编程-多线程.多进程和线程池编程 Python3高级核心技术97讲 笔记 目录 第十章:Python高级编程-多线程.多进程和线程池编程 10.1 Python中的GIL 10 ...

  2. python高级编程:有用的设计模式3

    # -*- coding: utf-8 -*-__author__ = 'Administrator'#python高级编程:有用的设计模式#访问者:有助于将算法从数据结构中分离出来"&qu ...

  3. python高级编程:有用的设计模式2

    # -*- coding: utf-8 -*- __author__ = 'Administrator' #python高级编程:有用的设计模式 #代理 """ 代理对一 ...

  4. python高级编程:有用的设计模式1

    # -*- coding: utf-8 -*-__author__ = 'Administrator'#python高级编程:有用的设计模式#设计械是可复用的,某种程序上它对软件设计中觉问题提供的语言 ...

  5. python高级编程技巧

    由python高级编程处学习 http://blog.sina.com.cn/s/blog_a89e19440101fb28.html Python列表解析语法[]和生成 器()语法类似 [expr  ...

  6. python高级编程之选择好名称:完

    由于时间关系,python高级编程不在放在这边进行学习了,如果需要的朋友可以看下面的网盘进行下载 # # -*- coding: utf-8 -*- # # python:2.x # __author ...

  7. python高级编程读书笔记(一)

    python高级编程读书笔记(一) python 高级编程读书笔记,记录一下基础和高级用法 python2和python3兼容处理 使用sys模块使程序python2和python3兼容 import ...

  8. python高级编程之列表推导式

    1. 一个简单的例子 在Python中,如果我们想修改列表中所有元素的值,可以使用 for 循环语句来实现. 例如,将一个列表中的每个元素都替换为它的平方: >>> L = [1, ...

  9. Python高级编程之生成器(Generator)与coroutine(二):coroutine介绍

    原创作品,转载请注明出处:点我 上一篇文章Python高级编程之生成器(Generator)与coroutine(一):Generator中,我们介绍了什么是Generator,以及写了几个使用Gen ...

随机推荐

  1. 08配置基础路径 同时导出一个函数和一个变量 封装微信请求Api

    地址===>https://www.bilibili.com/video/av58993009/?p=46 1==>配置基础路径同时导出一个函数和一个变量 var mynetwork= f ...

  2. jmeter压测学习4-正则表达式提取

    前言 上一个接口返回的token作为下个接口的入参,除了前面一篇讲到的用json提取器提取,也可以用正则提取. json提取器只能提取json格式的数据,正则可以匹配任意的返回. 我现在有一个登陆接口 ...

  3. IDEA结合Maven的profile构建不同开发环境(SpringBoot)

    一.概述 在开发过程中,我们的项目会存在不同的开发环境,比如开发环境.生产环境.测试环境,而我们的项目在不同的环境中有些配置也是不一样的,比如数据源配置.日志文件配置等,假如我们每次将软件部署到不同的 ...

  4. day8_7.8 文件操作

    一.文件模式 1.在文件的操作中,也有很多补充 的模式可使用 1.r+,可读可写模式,在此模式中,操作权限时可读可写,这里的写与write模式不一样的是,不再清空文件内容,写的内容添加到文件的后面,而 ...

  5. RSA介绍

    RSA加密算法是一种非对称加密算法.在公开密钥加密和电子商业中RSA被广泛使用. 公钥(Public Key)与私钥(Private Key)是通过一种算法得到的一个密钥对(即一个公钥和一个私钥),公 ...

  6. [Algorithm] 617. Merge Two Binary Trees

    Given two binary trees and imagine that when you put one of them to cover the other, some nodes of t ...

  7. [LeetCode] 882. Reachable Nodes In Subdivided Graph 细分图中的可到达结点

    Starting with an undirected graph (the "original graph") with nodes from 0 to N-1, subdivi ...

  8. [LeetCode] 40. Combination Sum II 组合之和之二

    Given a collection of candidate numbers (candidates) and a target number (target), find all unique c ...

  9. Elasticsearch由浅入深(七)搜索引擎:_search含义、_multi-index搜索模式、分页搜索以及深分页性能问题、query string search语法以及_all metadata原理

    _search含义 _search查询返回结果数据含义分析 GET _search { , "timed_out": false, "_shards": { , ...

  10. 深入学习 esp8266 wifimanager源码解析(打造专属自己的web配网)

    QQ技术互动交流群:ESP8266&32 物联网开发 群号622368884,不喜勿喷 单片机菜鸟博哥CSDN 1.前言 废话少说,本篇博文的目的就是深入学习 WifiManager 这个gi ...