python进程锁和线程锁,python线程池用的什么锁

　　本文介绍了python的一些知识，主要介绍了进程池和进程锁的相关问题，包括进程池的创建模块、进程池函数等。下面就一起来看看吧，希望对你有帮助。

　　推荐：python视频教程

　　00-1010

进程池

　　我们可以把进程池想象成一个预先创建了一定数量进程的池。见下图：

　　例如，这个红色矩形阵列代表一个进程池，其中有六个进程。这六个进程将与进程池一起创建。不仅如此，我们在学习面向对象生命周期的时候，曾经说过，每一个实例化的对象，用完后都会被内存管理器回收。

　　我们的进程也会随着创建和关闭的进程被内存管理器回收，每一个都是一样的。通过关闭进程创建的进程也会消耗一些性能。而进程池中的进程在创建后不会被关闭，可以一直被重用，避免了关闭造成的资源消耗和关闭造成的重复操作，提高了效率。

　　当然，当我们执行完程序，进程池关闭时，进程也会关闭。

　　当我们有一个任务要执行时，我们会判断当前进程池中是否有空闲进程(所谓空闲进程，其实就是进程池中没有在执行任务的进程)。如果一个进程是空闲的，任务会找到一个进程来执行任务。如果当前进程池中的所有进程都不空闲，那么任务将进入等待状态，直到进程池中有空闲的进程，才会进入或离开进程池，从而执行任务。

　　这就是进程池的用途。

　　00-1010

什么是进程池

　　00-1010当创建进程池对象时，我们必须处理它。我们来看看一些常用的方法(函数)。

　　函数名引入参数返回值apply_async task加入进程池(异步)func，args no close关闭进程池no join等待进程池任务结束no apply_async函数：其作用是将任务加入进程池，异步实现。我们还没有学过异步的这些知识，所以不要管它是什么意思。它有两个参数：func和agrs，func是加入进程池的函数；Args是一个tuple，代表一个函数的参数，和我们创建和使用一个进程的时候完全一样。关闭函数：当我们使用完进程池后，我们可以通过调用关闭函数来关闭进程池。它没有参数，也没有返回值。Join函数：与我们上一章学习的创建过程的join函数中的方法一致。只有在执行完进程池中的所有任务后，才会执行后续任务。但是，它通常在进程池关闭时使用(close函数)。

　　/ul>

apply_async 函数演示案例

• 定义一个函数，打印输出该函数 每次被执行的次数 与 该次数的进程号
• 定义进程池的数量，每一次的执行进程数量最多为该进程池设定的进程数

# coding:utf-8import osimport timeimport multiprocessingdef work(count): 
　　# 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
　　 print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
　　 time.sleep(3)
　　 # print('********')if __name__ == '__main__':
　　 pool = multiprocessing.Pool(3) 
　　 # 定义进程池的进程数量，同一时间每次执行最多3个进程
　　 for i in range(21):
　　 pool.apply_async(func=work, args=(i,)) 
　　 # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
　　 time.sleep(15) 
　　 # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。

　　从上图中我们可以看到每一次都是一次性运行三个进程，每一个进程的进程号是不一样的，但仔细看会发现存在相同的进程号，这说明进程池的进程号在被重复利用。这证明我们上文介绍的内容，进程池中的进程不会被关闭，可以反复使用。

　　而且我们还可以看到每隔3秒都会执行3个进程，原因是我们的进程池中只有3个进程；虽然我们的 for 循环 中有 21 个任务，work 函数会被执行21次，但是由于我们的进程池中只有3个进程。所以当执行了3个任务之后（休眠3秒），后面的任务等待进程池中的进程处于空闲状态之后才会继续执行。

　　同样的，进程号在顺序上回出现一定的区别，原因是因为我们使用的是一种 异步 的方法（异步即非同步）。这就导致 work 函数 一起执行的三个任务会被打乱顺序，这也是为什么我们的进程号出现顺序不一致的原因。（更多的异步知识我们会在异步的章节进行详细介绍）

　　进程池的原理： 上述脚本的案例证实了我们进程池关于进程的限制，只有当我们进程池中的进程处于空闲状态的时候才会将进程池外等待的任务扔到进程池中工作。

close 函数与 join 函数 演示

　　如果没有 time.sleep(15) 这句话又怎么办呢，其实这里就可以使用进程的 join 函数了。不过上文我们也提到过，进程的 join() 函数一般都会伴随进程池的关闭（close 函数）来使用。接下来，我们就将上文脚本中的 time.sleep(15) 替换成 join() 函数试一下。

　　示例代码如下：

# coding:utf-8import osimport timeimport multiprocessingdef work(count): 
　　# 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
　　 print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
　　 time.sleep(3)
　　 # print('********')if __name__ == '__main__':
　　 pool = multiprocessing.Pool(3) # 定义进程池的进程数量，同一时间每次执行最多3个进程
　　 for i in range(21):
　　 pool.apply_async(func=work, args=(i,)) 
　　 # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
　　 # time.sleep(15) 
　　 pool.close()
　　 pool.join()

　　从上面的动图我们可以看出，work() 函数的任务与进程池中的进程与使用 time.sleep(15)的运行结果一致。

　　PS：如果我们的主进程会一直执行，不会退出。那么我们并不需要添加 close() 与 join() 函数 ，可以让进程池一直启动着，直到有任务进来就会执行。

　　在后面学习 WEB 开发之后，不退出主进程进行工作是家常便饭。还有一些需要长期执行的任务也不会关闭，但要是只有一次性执行的脚本，就需要添加 close() 与 join() 函数 来保证进程池的任务全部完成之后主进程再退出。当然，如果主进程关闭了，就不会再接受新的任务了，也就代表了进程池的终结。

接下来再看一个例子，在 work 函数 中加入一个 return。

　　这里大家可能会有一个疑问，在上一章节针对进程的知识点明明说的是 进程无法获取返回值，那么这里的 work() 函数增加的 return 又有什么意义呢？

　　其实不然，在我们的使用进程池的 apply_async 方法时，是通过异步的方式实现的，而异步是可以获取返回值的。针对上述脚本，我们在 for循环中针对每一个异步 apply_async 添加一个变量名，从而获取返回值。

　　

# coding:utf-8import osimport timeimport multiprocessingdef work(count): # 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
　　 print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
　　 time.sleep(3)
　　 return '\'work\' 函数 result 返回值为：{}, 进程ID为：{}'.format(count, os.getpid())if __name__ == '__main__':
　　 pool = multiprocessing.Pool(3) # 定义进程池的进程数量，同一时间每次执行最多3个进程
　　 results = []
　　 for i in range(21):
　　 result = pool.apply_async(func=work, args=(i,)) # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
　　 results.append(result)
　　 for result in results:
　　 print(result.get()) # 可以通过这个方式返回 apply_async 的返回值，
　　 # 通过这种方式也不再需要 使用 close()、join() 函数就可以正常执行。
　　 # time.sleep(15) # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。
　　 # pool.close()
　　 # pool.join()

　　从运行结果可以看出，首先 work() 函数被线程池的线程执行了一遍，当第一组任务执行完毕紧接着执行第二次线程池任务的时候，打印输出了 apply_async 的返回值，证明返回值被成功的返回了。然后继续下一组的任务…

　　这些都是主要依赖于 异步 ，关于 异步 的更多知识会在 异步 的章节进行详细的介绍。

进程锁

进程锁的概念

　　结合这个场景来举一个例子：比如现在有多个进程同时冲向一个 "大门" ，当前门内是没有 "人"的(其实就是进程)，锁也没有锁上。当有一个进程进去之后并且把 “门” 锁上了，这时候门外的那些进程是进不来的。在门内的 “人” ，可以在 “门” 内做任何事情且不会被干扰。当它出来之后，会解开门锁。这时候又有一个 “人” 进去了门内，并且重复这样的操作，这就是 进程锁。它可以让锁后面的工作只能被一个任务来处理，只有它解锁之后下一个任务才会进入，这就是 “锁” 的概念。

　　而 进程锁 就是仅针对于 进程 有效的锁，当进程的任务开始之后，就会被上一把 “锁”；与之对应的是 线程锁 ，它们的原理几乎是一样的。

进程锁的加锁与解锁

通过 multiprocessing 导入 Manager 类

　　from multiprocessing import Manager

　　然后实例化 Manager

　　manager = Manager()

　　再然后通过实例化后的 manager 调用 它的 Lock() 函数

　　lock = manager.Lock()

　　接下来，就需要操作这个 lock 对象的函数

　　函数名介绍参数返回值acquire上锁无无release解锁（开锁）无无

# coding:utf-8import osimport timeimport multiprocessingdef work(count, lock): # 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号,增加线程锁。
　　 lock.acquire() # 上锁
　　 print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
　　 time.sleep(3)
　　 lock.release() # 解锁
　　 return '\'work\' 函数 result 返回值为：{}, 进程ID为：{}'.format(count, os.getpid())if __name__ == '__main__':
　　 pool = multiprocessing.Pool(3) # 定义进程池的进程数量，同一时间每次执行最多3个进程
　　 manager = multiprocessing.Manager()
　　 lock = manager.Lock()
　　 results = []
　　 for i in range(21):
　　 result = pool.apply_async(func=work, args=(i, lock)) # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
　　 # results.append(result)
　　 # time.sleep(15) # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。
　　 pool.close()
　　 pool.join()

　　从上图中，可以看到每一次只有一个任务会被执行。由于每一个进程会被阻塞 3秒钟，所以我们的进程执行的非常慢。这是因为每一个进程进入到 work() 函数中，都会执行 上锁、阻塞3秒、解锁 的过程，这样就完成了一个进程的工作。下一个进程任务开始，重复这个过程… 这就是 进程锁的概念。

　　锁 的使用可以让我们对某个任务 在同一时间只能对一个进程进行开发，但是 锁也不可以乱用 。因为如果某些原因造成 锁没有正常解开 ，就会造成死锁的现象，这样就无法再进行操作了。

　　因为 锁如果解不开 ，后面的任务也就没有办法继续执行任务，所以使用锁一定要谨慎。

　　推荐学习：python视频教程以上就是详细了解Python进程池与进程锁的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。