正文
python给函数加锁 pythongil锁
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
Python多线程总结
在实际处理数据时，因系统内存有限，我们不可能一次把所有数据都导出进行操作，所以需要批量导出依次操作。为了加快运行，我们会采用多线程的方法进行数据处理， 以下为我总结的多线程批量处理数据的模板：
主要分为三大部分：
共分4部分对多线程的内容进行总结。
先为大家介绍线程的相关概念:
在飞车程序中，如果没有多线程，我们就不能一边听歌一边玩飞车，听歌与玩 游戏 不能并行；在使用多线程后，我们就可以在玩 游戏 的同时听背景音乐。在这个例子中启动飞车程序就是一个进程，玩 游戏 和听音乐是两个线程。
Python 提供了 threading 模块来实现多线程:
因为新建线程系统需要分配资源、终止线程系统需要回收资源，所以如果可以重用线程，则可以减去新建/终止的开销以提升性能。同时，使用线程池的语法比自己新建线程执行线程更加简洁。
Python 为我们提供了 ThreadPoolExecutor 来实现线程池，此线程池默认子线程守护。它的适应场景为突发性大量请求或需要大量线程完成任务，但实际任务处理时间较短。
其中 max_workers 为线程池中的线程个数，常用的遍历方法有 map 和 submit+as_completed 。根据业务场景的不同，若我们需要输出结果按遍历顺序返回，我们就用 map 方法，若想谁先完成就返回谁，我们就用 submit+as_complete 方法。
我们把一个时间段内只允许一个线程使用的资源称为临界资源，对临界资源的访问，必须互斥的进行。互斥，也称间接制约关系。线程互斥指当一个线程访问某临界资源时，另一个想要访问该临界资源的线程必须等待。当前访问临界资源的线程访问结束，释放该资源之后，另一个线程才能去访问临界资源。锁的功能就是实现线程互斥。
我把线程互斥比作厕所包间上大号的过程，因为包间里只有一个坑，所以只允许一个人进行大号。当第一个人要上厕所时，会将门上上锁，这时如果第二个人也想大号，那就必须等第一个人上完，将锁解开后才能进行，在这期间第二个人就只能在门外等着。这个过程与代码中使用锁的原理如出一辙，这里的坑就是临界资源。 Python 的 threading 模块引入了锁。 threading 模块提供了 Lock 类，它有如下方法加锁和释放锁：
我们会发现这个程序只会打印“第一道锁”，而且程序既没有终止，也没有继续运行。这是因为 Lock 锁在同一线程内第一次加锁之后还没有释放时，就进行了第二次 acquire 请求，导致无法执行 release ，所以锁永远无法释放，这就是死锁。如果我们使用 RLock 就能正常运行，不会发生死锁的状态。
在主线程中定义 Lock 锁，然后上锁，再创建一个子 线程t 运行 main 函数释放锁，结果正常输出，说明主线程上的锁，可由子线程解锁。
如果把上面的锁改为 RLock 则报错。在实际中设计程序时，我们会将每个功能分别封装成一个函数，每个函数中都可能会有临界区域，所以就需要用到 RLock 。
一句话总结就是 Lock 不能套娃， RLock 可以套娃； Lock 可以由其他线程中的锁进行操作， RLock 只能由本线程进行操作。
相关问答
Q1: python有1000个url请求 放到queue 再十个线程 这样输出的数据是乱的 必须加锁么
题主的问题表述不清python给函数加锁，尤其十个线程做了哪些工作没说明，python给函数加锁我从字面猜测，是把1000个url放在队列里，然后十个线程从队列中取出url，请求之后，调用输出函数。
先说队列的问题，通常的设计里，queue只在添加元素，摘取元素的时候内部加锁，以保证队列数据不出错，至于从queue中取出数据后怎么处理，要不要放临界区，queue是不管的，也不应该管，python的Queue模块提供了相应的Queue类。
再说输出结果是乱的，又是表述不清，如果你指的是最终输出到一个文件里，文件内容乱了，那给你4种解决办法python给函数加锁：
1. 线程里每个url在请求到内容后，在写文件时设立临界区，保证串行输出，强烈不建议这种方式。
2. 对每个url的请求内容写一个文件，最后合并文件，这种最灵活。
3. 对每个工作线程的输出写一个文件，最后合并文件，最有并行style
4. 对每个url的请求内容再次写到一个队列里，另一个线程读取此队列写文件，最有设计模式style
如果你要保证输出结果是与输入url同序的，建议你采用上面第2种办法，合并文件的时候保证与url队列同序
Q2: 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 = item def run(self):
time.sleep(2)
value = 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 = 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 = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):
Q3: 下面这段python的多线程代码为什么运行不起来，说是函数没有加锁的属性
下面的代码可以，因为你那个lock是变量又是函数，会冲突的，另外，你这个实验其实测试不出来lock属性，因为你调用实际上是顺序的
import string,socket,time,os,sys,threading
num=0
class xThread():
def __init__(self):
self._lock=threading.Lock()
def lock(self):
self._lock.acquire()
def unlock(self):
self._lock.release()
def p2(a):
global num
thread.lock()
num+=1
print(a+str(num))
time.sleep(0.1)
thread.unlock()
def p1(a):
for i in range(3):
info='this %s thread'%(i)
p2(info)
def main():
for i in range(3):
p1(i)
if __name__ == '__main__':
thread=xThread()
main()
python给函数加锁的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于pythongil锁、python给函数加锁的信息别忘了在本站进行查找喔。
