锐客网

  1. 首页 > 生活百科 > it技术 > >

python函数加锁 python 加锁

线程IT技术

Python中的各种锁？大致罗列一下：
一、全局解释器锁（GIL）
1、什么是全局解释器锁
每个CPU在同一时间只能执行一个线程，那么其他python函数加锁的线程就必须等待该线程的全局解释器 ， 使用权消失后才能使用全局解释器，即使多个线程直接不会相互影响在同一个进程下也只有一个线程使用cpu ， 这样的机制称为全局解释器锁（GIL） 。GIL的设计简化python函数加锁了CPython的实现 ， 使的对象模型包括关键的内建类型，如：字典等，都是隐含的，可以并发访问的，锁住全局解释器使得比较容易的实现对多线程的支持，但也损失了多处理器主机的并行计算能力 。
2、全局解释器锁的好处
1）、避免了大量的加锁解锁的好处
2）、使数据更加安全，解决多线程间的数据完整性和状态同步
3、全局解释器的缺点
多核处理器退化成单核处理器，只能并发不能并行 。
4、GIL的作用：
多线程情况下必须存在资源的竞争，GIL是为了保证在解释器级别的线程唯一使用共享资源（cpu） 。
二、同步锁
1、什么是同步锁？
同一时刻的一个进程下的一个线程只能使用一个cpu，要确保这个线程下的程序在一段时间内被cpu执，那么就要用到同步锁 。
2、为什么用同步锁？
因为有可能当一个线程在使用cpu时，该线程下的程序可能会遇到io操作，那么cpu就会切到别的线程上去，这样就有可能会影响到该程序结果的完整性 。
3、怎么使用同步锁？
只需要在对公共数据的操作前后加上上锁和释放锁的操作即可 。
4、同步锁的所用：
为了保证解释器级别下的自己编写的程序唯一使用共享资源产生了同步锁 。
三、死锁
1、什么是死锁？
指两个或两个以上的线程或进程在执行程序的过程中 ， 因争夺资源或者程序推进顺序不当而相互等待的一个现象 。
2、死锁产生的必要条件？
互斥条件、请求和保持条件、不剥夺条件、环路等待条件
3、处理死锁的基本方法？
预防死锁、避免死锁（银行家算法）、检测死锁（资源分配）、解除死锁：剥夺资源、撤销进程
四、递归锁
在Python中为了支持同一个线程中多次请求同一资源，Python提供了可重入锁 。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数 ， 从而使得资源可以被多次require 。直到一个线程所有的acquire都被release ， 其他的线程才能获得资源 。递归锁分为可递归锁与非递归锁 。
五、乐观锁
假设不会发生并发冲突 ， 只在提交操作时检查是否违反数据完整性 。
六、悲观锁
假定会发生并发冲突 ， 屏蔽一切可能违反数据完整性的操作 。
python常用的加锁方式：互斥锁、可重入锁、迭代死锁、互相调用死锁、自旋锁大致罗列一下：
一、全局解释器锁（GIL）
1、什么是全局解释器锁
每个CPU在同一时间只能执行一个线程，那么其他的线程就必须等待该线程的全局解释器，使用权消失后才能使用全局解释器，即使多个线程直接不会相互影响在同一个进程下也只有一个线程使用cpu ， 这样的机制称为全局解释器锁（GIL） 。GIL的设计简化了CPython的实现 ， 使的对象模型包括关键的内建类型 ， 如：字典等，都是隐含的，可以并发访问的，锁住全局解释器使得比较容易的实现对多线程的支持，但也损失了多处理器主机的并行计算能力 。
2、全局解释器锁的好处
1）、避免了大量的加锁解锁的好处
2）、使数据更加安全，解决多线程间的数据完整性和状态同步
3、全局解释器的缺点
多核处理器退化成单核处理器，只能并发不能并行 。
4、GIL的作用：
多线程情况下必须存在资源的竞争，GIL是为了保证在解释器级别的线程唯一使用共享资源（cpu） 。
二、同步锁
1、什么是同步锁？
同一时刻的一个进程下的一个线程只能使用一个cpu，要确保这个线程下的程序在一段时间内被cpu执，那么就要用到同步锁 。
2、为什么用同步锁？
因为有可能当一个线程在使用cpu时，该线程下的程序可能会遇到io操作，那么cpu就会切到别的线程上去，这样就有可能会影响到该程序结果的完整性 。
3、怎么使用同步锁？
只需要在对公共数据的操作前后加上上锁和释放锁的操作即可 。
4、同步锁的所用：
为了保证解释器级别下的自己编写的程序唯一使用共享资源产生了同步锁 。
三、死锁
1、什么是死锁？
指两个或两个以上的线程或进程在执行程序的过程中，因争夺资源或者程序推进顺序不当而相互等待的一个现象 。
2、死锁产生的必要条件？
互斥条件、请求和保持条件、不剥夺条件、环路等待条件
3、处理死锁的基本方法？
预防死锁、避免死锁（银行家算法）、检测死锁（资源分配）、解除死锁：剥夺资源、撤销进程
四、递归锁
在Python中为了支持同一个线程中多次请求同一资源，Python提供了可重入锁 。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require 。直到一个线程所有的acquire都被release，其他的线程才能获得资源 。递归锁分为可递归锁与非递归锁 。
五、乐观锁
假设不会发生并发冲突 ， 只在提交操作时检查是否违反数据完整性 。
六、悲观锁
假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作 。
python常用的加锁方式：互斥锁、可重入锁、迭代死锁、互相调用死锁、自旋锁
Python中级精华-临界区加锁概念梳理：
临界区：
临界区指的是一个访问共用资源（例如：共用设备或是共用存储器）的程序片段
，而这些共用资源又无法同时被多个线程访问的特性 。当有线程进入临界区段时，其他线程或是进程必须等待，有一些同步的机制必须在临界区段的进入点与离开点实现 ， 以确保这些共用资源是被互斥获得使用 。
目的：
我们在多线程
处理是 ， 经常会涉及到对于一块共享资源的访问，这里就需要线程可以互斥去避免出现竞态条件（race condition）.
方法：
要想让可变对象安全地在多线程环境中进行访问，就要使用锁变量（threading中的LockRLock） ， 锁变量也是同步原语
中的最常见一种之一 。
示例：
【python函数加锁 python 加锁】 线程的调度从本质上来说是非确定性的（只能保证独一访问，但保证不了谁先谁后） 。只要共享的可变状态需要被多个线程访问，就要使用锁机制，保证数据的安全 。
在threading库中我们也发现了其他的同步原语例如：RLock（可重入锁）、Semaphore对象（信号量） 。
RLock:可以被同一个线程多次获取，主要用来编写基于锁的代码，或者基于‘监听器’的同步处理 。
当某个类持有这种类型锁时，只有一个线程可以使用类中全部函数或者方法，例如：
这份代码中只有一个作用于整个类的锁 ， 它被所有的类实例所共享，不再将所绑定在某个实例的可变状态上，现在这个锁是用来同步类中的方法的 。对于其他标准锁不同的是，对于已经持有了该锁的方法可以调用同样使用了这个锁的其他方法（参考sub_one()） 。
这个实现的特点是，无论创建了多少counter实例 ， 这些实例共有同一把锁 。因此，当有大量counter出现时，这种方法堆内存的使用效率要高很多 。但是可能存在的缺点是在使用了大量线程且需要频繁更新counter中的数据时 ， 这么做会出现锁争用的情况 。
另外一种同步原语semaphore,是一种基于共享计数器的同步原语 。如果计数器非0，那么with语句会递减计数器并且允许线程继续执行 。当with语句块结束后，会将计数器递增 。如果计数器为0，那么执行过程会被阻塞，直到由另外一个线程来递增计数器为止 。由于信号量
的实现更为复杂，这会对程序带来一定的负面影响 。除了简单地加锁功能外，信号量对象对于那些设计在线程间发送信号或者需要实现节流处理的应用中更加有用，例如限制并发总数：
python多线程全局变量和锁1.python中数据类型，int,float,复数 ， 字符，元组 ， 做全局变量时需要在函数里面用global申明变量，才能对变量进行操作 。
而，对象，列表，词典 ， 不需要声明，直接就是全局的 。
2.线程锁mutex=threading.Lock()
创建后就是全局的 。线程调用函数可以直接在函数中使用 。
mutex.acquire()开启锁
mutex=release()关闭锁
要注意，死锁的情况发生 。
注意运行效率的变化:
正常1秒 ， 完成56997921
加锁之后，1秒只运行了531187 ， 相差10倍多 。
3.继承.threading.Thread的类，无法调用__init__函数 ， 无法在创建对象时初始化新建的属性 。
4.线程在cpu的执行，有随机性
5. 新建线程时 ， 需要传参数时，args是一个元组，如果只有一个参数，一定后面要加一个,符号 。不能只有一个参数否则线程会报创建参数错误 。threading.Thread(target=fuc,args=(arg,))
python多线程几种方法实现Python进阶(二十六)-多线程实现同步python函数加锁的四种方式
临界资源即那些一次只能被一个线程访问的资源python函数加锁，典型例子就是打印机python函数加锁，它一次只能被一个程序用来执行打印功能python函数加锁，因为不能多个线程同时操作，而访问这部分资源的代码通常称之为临界区 。
锁机制
threading的Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock()def add(self):
self.lock.acquire()#加锁，锁住相应的资源
self.num= 1
num = self.num
self.lock.release()#解锁，离开该资源
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = itemdef run(self):
time.sleep(2)
value = https://www.04ip.com/post/n.add()#将num加1，并输出原来的数据和 1之后的数据
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使线程一个一个执行12345678910111213141516171819202122232425262728
当一个线程调用锁的acquire()方法获得锁时 ， 锁就进入“locked”状态 。每次只有一个线程可以获得锁 。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞”（参见多线程的基本概念） 。
直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态 。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态 。
信号量
信号量也提供acquire方法和release方法 ， 每当调用acquire方法的时候，如果内部计数器大于0，则将其减1，如果内部计数器等于0，则会阻塞该线程，知道有线程调用了release方法将内部计数器更新到大于1位置 。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = https://www.04ip.com/post/3)#允许最多三个线程同时访问资源
def add(self):
self.sem.acquire()#内部计数器减1
self.num= 1
num = self.num
self.sem.release()#内部计数器加1
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = itemdef run(self):
time.sleep(2)
value = https://www.04ip.com/post/n.add()
print(self.item,value)for item in range(100):
关于python函数加锁和python 加锁的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息 ， 记得收藏关注本站 。

    推荐阅读


    上一篇：索尼账号服务器出了什么问题？ 索尼怎么该账号服务器

    下一篇：如何建立自己的文件服务器？ 怎么弄出文件服务器