Python 프로세스 풀 및 프로세스 잠금에 대해 자세히 알아보기

이 글은 프로세스 풀 생성 모듈, 프로세스 풀 기능 등을 포함하여 프로세스 풀 및 프로세스 잠금과 관련된 문제를 주로 소개하는 python에 대한 관련 지식을 제공합니다. 모두에게 도움이 되기를 바랍니다.

추천 학습: python 비디오 튜토리얼

프로세스 풀

프로세스 풀이란 무엇입니까

프로세스에 대해 이전 장에서 너무 많은 프로세스가 생성되면 리소스가 소비될 것이라고 언급했습니다. 너무 큽니다. 이러한 상황을 피하기 위해서는 프로세스 수를 수정해야 하는데 이때 프로세스 풀의 도움이 필요합니다.

프로세스 풀은 일정 개수의 프로세스가 미리 생성되어 있는 풀이라고 생각하면 됩니다. 아래 그림을 참조하세요.

---

---

예를 들어, 이 빨간색 직사각형 배열은 프로세스 풀을 나타내며 이 풀에는 6개의 프로세스가 있습니다. 이 6개의 프로세스는 프로세스 풀과 함께 생성됩니다. 그뿐만 아니라 객체 지향 생명주기를 배울 때 인스턴스화된 각 객체는 사용 후 메모리 관리자에 의해 재활용된다고 말한 적이 있습니다.

우리 프로세스는 생성 및 종료 프로세스와 함께 메모리 관리자에 의해 재활용됩니다. 이는 프로세스가 닫힐 때 생성되는 프로세스도 일정량의 성능을 소비하게 됩니다. 프로세스 풀의 프로세스는 생성된 후에도 닫히지 않고 항상 재사용될 수 있으므로 생성 및 닫기의 리소스 소비를 방지하고 생성 및 닫기의 반복 작업을 방지하여 효율성을 향상시킵니다.

물론, 프로그램 실행이 끝나고 프로세스 풀이 닫히면 프로세스도 닫힙니다.

실행해야 할 작업이 있으면 현재 프로세스 풀에 유휴 프로세스가 있는지 확인합니다(소위 유휴 프로세스는 실제로 작업을 실행하지 않는 프로세스 풀의 프로세스입니다). 프로세스가 유휴 상태이면 작업은 작업을 수행할 프로세스를 찾습니다. 현재 프로세스 풀의 모든 프로세스가 유휴 상태가 아닌 경우 작업은 대기 상태로 들어가고 프로세스 풀의 프로세스가 작업을 실행하기 위해 유휴 상태가 될 때까지 프로세스 풀에 들어가거나 나가지 않습니다.

프로세스 풀의 역할입니다.

프로세스 풀 생성 모듈 - multiprocessing

프로세스 풀 기능 생성 - Pool

함수 이름	소개	Parameters	반환 값
P ool	프로세스 풀	Processcount	프로세스 풀 개체

Pool功能介绍：通过调用 "multiprocessing" 模块的 "Pool" 函数来帮助我们创建 "进程池对象" ，它有一个参数 "Processcount" （一个整数），代表我们这个进程池中创建几个进程。

프로세스 풀의 일반적인 방법

프로세스 풀 개체를 만든 후에는 해당 프로세스를 작동해야 합니다. 방법(기능).

함수 이름	소개	Parameters	반환 값
apply_async	프로세스 풀에 추가된 작업(비동기)	func, args	없음
닫기	프로세스 풀 닫기	None	None
join	프로세스 풀 작업이 종료되기를 기다리는 중	None	None

• apply_async 함수: 프로세스 풀에 작업을 추가하는 기능이며 비동기식으로 구현됩니다. 비동기 우리는 아직 이 지식을 배우지 않았으므로 이것이 무엇을 의미하는지 걱정할 필요가 없습니다. 여기에는 func 및 ags라는 두 개의 매개변수가 있습니다. func는 프로세스 풀에 추가된 함수입니다. args는 함수의 매개변수를 나타내는 튜플입니다. 이는 프로세스를 생성하고 사용할 때와 같습니다. .완전히 일관성이 있습니다.
异步 这个知识我们还没有学习，先不用关心它到底是什么意思。它有两个参数：func 与 agrs , func 是加入进程池中工作的函数；args 是一个元组，代表着签一个函数的参数，这和我们创建并使用一个进程是完全一致的。
• close 函数：当我们使用完进程池之后，通过调用 close 函数可以关闭进程池。它没有任何的参数，也没有任何的返回值。
• join 函数：它和我们上一章节学习的 创建进程的 join 函数中方法是一致的。只有进程池中的任务全部执行完毕之后，才会执行后续的任务。不过一般它会伴随着进程池的关闭（close 函数）才会使用。

apply_async 函数演示案例

接下里我们在 Pycharm 中创建一个脚本，练习一下关于进程池的使用方法。

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

示例代码如下：

# 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) 帮助我们将主进程阻塞15秒钟再次退出，所以给了我们进程池足够的时间完成我们的 work() 函数的循环任务。

如果没有 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() 函数增加的 returnclose 함수: 프로세스 풀 사용을 마친 후 close 함수를 호출하여 프로세스 풀을 닫을 수 있습니다. 매개변수도 없고 반환 값도 없습니다.

join 함수: 프로세스를 생성하기 위해 이전 장에서 배운 Join 함수와 일치합니다. 프로세스 풀의 모든 작업이 실행된 후에만 후속 작업이 실행됩니다. 다만, 일반적으로 프로세스 풀을 닫을 때(close 함수) 사용합니다.

apply_async 함수 데모 사례

다음으로 프로세스 풀 사용 방법을 연습하기 위해 Pycharm에서 스크립트를 생성합니다. 🎜🎜🎜🎜함수를 정의하고 함수가 매번 실행되는 횟수와 해당 횟수의 프로세스 번호를 인쇄합니다.🎜각 시간에 실행되는 프로세스 수를 정의합니다. 프로세스 풀에 설정된 프로세스 수

샘플 코드는 다음과 같습니다. 🎜

# 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()

실행 결과는 다음과 같습니다. 🎜

---

🎜

위 그림을 보면 3개의 프로세스가 동시에 실행될 때마다 각 프로세스의 프로세스 번호가 다르지만 자세히 보면 동일한 프로세스 번호가 존재하는 것을 알 수 있습니다. 프로세스 풀의 프로세스 번호가 재사용되고 있음을 나타냅니다. 이는 위에서 소개한 내용을 증명하며, 프로세스 풀의 프로세스는 닫히지 않고 반복적으로 사용될 수 있습니다. 🎜

그리고 for 루프에는 21개의 작업이 있지만 프로세스 풀에는 3개의 프로세스만 있으므로 3초마다 3개의 프로세스가 실행되는 것을 볼 수 있습니다. 21번 실행되지만 프로세스 풀에는 프로세스가 3개만 있기 때문입니다. 따라서 3개의 작업을 실행한 후(3초 동안 대기) 후속 작업은 실행을 계속하기 전에 프로세스 풀의 프로세스가 유휴 상태가 될 때까지 기다립니다. 🎜

마찬가지로 프로세스 번호 순서에도 일정한 차이가 있는 이유는 비동기 방식(비동기란 비동기를 의미함)을 사용하기 때문입니다. 이로 인해 작업 함수에 의해 함께 실행되는 세 가지 작업이 순서에 맞지 않게 되고, 이것이 바로 프로세스 번호가 일관되지 않은 순서로 나타나는 이유입니다. (비동기 장에서 더 자세한 비동기 지식을 소개하겠습니다) 🎜

프로세스 풀의 원리: 위 스크립트 사례는 프로세스에 대한 프로세스 풀의 한계를 확인합니다. 프로세스 풀의 프로세스는 유휴 상태이며, 프로세스 풀 외부에서 대기 중인 작업은 작업을 위해 프로세스 풀로 처리됩니다. 🎜

---

함수 닫기 및 조인 함수 데모

위 스크립트에서는 time.sleep(15) 을 사용합니다. code>는 다시 종료하기 전에 15초 동안 기본 프로세스를 차단하는 데 도움이 되므로 프로세스 풀에 work() 함수의 루프 작업을 완료하는 데 충분한 시간을 제공합니다. 🎜<p><code>time.sleep(15) 문장이 없으면 어떻게 될까요? 실제로 여기서 프로세스의 join 함수를 사용할 수 있습니다. 하지만 위에서도 프로세스의 join() 함수는 일반적으로 프로세스 풀이 닫힐 때(close 함수) 사용된다는 점을 언급했습니다. 다음으로, 위 스크립트에서 time.sleep(15)를 join() 함수로 바꿔보겠습니다. 🎜

샘플 코드는 다음과 같습니다. 🎜

# 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()

실행 결과는 다음과 같습니다. 🎜

---

🎜

위 애니메이션에서 의 작업이 작동하는 것을 볼 수 있습니다. () 함수 프로세스 풀에서 프로세스를 실행한 결과는 time.sleep(15)를 사용한 것과 일치합니다. 🎜

PS: 기본 프로세스가 항상 실행된다면 종료되지 않습니다. 그러면 close() 및 Join() 함수를 추가할 필요가 없으며 작업이 들어와 실행될 때까지 프로세스 풀을 시작된 상태로 유지할 수 있습니다. 🎜

나중에 WEB 개발을 배운 후에는 메인 프로세스를 종료하지 않고 작업하는 것이 일반적입니다. 장시간 실행해야 닫히지 않는 작업도 있지만, 일회성 실행 스크립트만 있는 경우 close() 및 Join() 함수 프로세스 풀의 모든 작업이 완료된 후 기본 작업이 완료되었는지 확인합니다. 프로세스가 다시 종료됩니다. 물론, 메인 프로세스가 닫히면 더 이상 새 작업을 허용하지 않으며, 이는 프로세스 풀의 종료를 의미합니다. 🎜<hr>🎜<p>다른 예를 살펴보고 <code>work 함수에 return을 추가해 보겠습니다. 🎜

여기서 궁금한 점이 있을 수 있습니다. 이전 장의 프로세스에 대한 지식 포인트에서 프로세스가 반환 값을 얻을 수 없습니다라고 명시되어 있으므로 여기서는 work()입니다. code> 함수에 추가된 <code>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秒、解锁 的过程，这样就完成了一个进程的工作。下一个进程任务开始，重复这个过程… 这就是 进程锁的概念。

---

其实进程锁还有很多种方法，在 multiprocessing 中有一个直接使用的锁，就是 ``from multiprocessing import Lock。这个Lock的锁使用和我们刚刚介绍的Manager` 的锁的使用有所区别。（这里不做详细介绍，感兴趣的话可以自行拓展一下。）

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

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

推荐学习：python视频教程

위 내용은 Python 프로세스 풀 및 프로세스 잠금에 대해 자세히 알아보기의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!