常連

# 状況
自作のモジュール内で`coucurrent.futures.ProcessPoolExecutor`を用いて並列処理を実装したいと考えています。
下記のコードで`MAX_WORKERS = 16`として実行したところ、`BrokenProcessPool`が発生しました。

```Python3
from concurrent import futures

class ExampleClass:
    def hoge(self):
        with futures.ProcessPoolExecutor(max_workers=MAX_WORKERS) as executor:
            results = executor.map(ExampleClass.fuga, arg)

    @staticmethod
    def fuga(arg):
        #何かしらの処理
```
発生するエラー
`concurrent.futures.process.BrokenProcessPool: A process in the process pool was terminated abruptly while the future was running or pending.`

# 試したこと
自分で原因を探ったところ、OSがプロセスをkillしている可能性があるとのことで、プロセス数を減らせばエラーが発生しないと考え`MAX_WORKERS = 8`とした場合には`BrokenProcessPool`は発生しませんでした。
また、公式のドキュメントを読んだところ、ProcessPoolExecutorの項で「If max_workers is None or not given, it will default to the number of processors on the machine.」とあったため`MAX_WORKERS = None`としたところ、`BrokenProcessPool`が発生しました。

また、`concurrent.futures.ProcessPoolExecutor`で実装する前に`multiprocessing.Pool`で実装していたのですが、その際は`MAX_WORKERS = 16`としてもエラーは発生しませんでした。
```
from multiprocessing import Pool
    ~~略~~
        with Pool(MAX_WORKERS) as p:
            results = p.map(ExampleClass.fuga, arg)
    ~~略~~
```

タスクマネージャーでCPUの使用率を観測しながら実行してみたところ、CPU使用率が100%に近づいた場合に`BrokenProcessPool`が発生するような印象を受けました。`MAX_WORKERS = 8`とした場合のCPU使用率は60~70%ほどでした。

# 知りたいこと
0. `BrokenProcessPool`が発生する原因、条件が知りたい。

0. `multiprocessing.Pool`では実行できるのに、`concurrent.futures.ProcessPoolExecutor`では実行できない理由が知りたい。
0. `MAX_WORKERS`の最適な数(エラーが発生せずに安全にタスクを完了できる数)の目安が知りたい。
0. 安全に並列処理を実行できる実装が知りたい。現在は`MAX_WORKERS = 8`とすれば一応動くが、他のタスクの実行中や現在のマシンよりも性能の劣るマシン上での実行などで、使用できるリソースが少ない状況でもエラーを出さずに実行したい。

また、「使用しているCPUは8コア16スレッドなので、`MAX_WORKERS`を増加させると`MAX_WORKERS = 16`まではタスクが高速になる可能性がある。」という認識は正しいでしょうか。

並列処理にはあまり詳しくないため、前提知識などが抜け落ちていた場合はご教示いただければ幸いです。
よろしくおねがいします。

# 環境
**CPU**
	Intel(R) Core(TM) i7-10700F CPU @ 2.90GHz

	基本速度:	2.90 GHz
	ソケット:	1
	コア:	8
	論理プロセッサ数:	16
	仮想化:	有効

**OS**
Windows10

**Python ver.**
Python 3.10.0

[Python]並列処理でプロセス数を増やすとエラーが発生する

### 知りたいこと
今日マルチスレッドについて触れたばかりです。
全体的に並列処理についての理解がありません。


OpenMPを使用してマルチスレッド化を試みているのですが、

並列計算をする際にCPUに記載されたコア数/スレッド数を超えたスレッド数を設定できます。
それによって計算速度も上昇します。
これが一体何を意味するのか、ということが知りたいです。

cpuはi7 9700F,8コア8スレッドです。
[https://ark.intel.com/content/www/jp/ja/ark/products/193738/intel-core-i7-9700f-processor-12m-cache-up-to-4-70-ghz.html](https://ark.intel.com/content/www/jp/ja/ark/products/193738/intel-core-i7-9700f-processor-12m-cache-up-to-4-70-ghz.html)

### 実装内容
並列計算は以下のように書いていて
```C++
#include <omp.h> // OpenMP
~~~~省略~~~~
int N = 1000000;
#pragma omp parallel for num_threads(num) // numの値がスレッド数にあたる
	for(int i = 0; i < N; i++)process(); // 100万の処理
```
process()は
```C++
	int num = 0;
	for(int i = 0; i < 10000; ++i) // 内部で1万ループする
	{
		++num;
	}
```

process内1個の計算時間は0.02msくらい

### 計測結果

スレッド数とその速度を表にまとめた図が下です。
![イメージ説明](349908fb44cfc0d2730f12d5802edcd3.png)

1~8スレッドまではCPUのコアが利用できるのでわかります。
16~512までCPUコア数、スレッド数超えた状態で指定すると、指定スレッド数が倍々で上がるにつれ計算効率が最大3%くらい上昇しています。
なぜ上昇するのかもよくわかってないんですが、
一番知りたいのは、CPUに記載されてるスレッド数を越して設定して大丈夫なのか？という点です。
どなたかご教授いただけますと幸いです。

マルチスレッドでCPUのコア/スレッド数を超えたスレッドを指定するということはどういうこと？

### 前提・実現したいこと

データセットがキーのアルファベット記号と要素の数字からなる辞書型で与えられており、
数字はリストに格納されています。リストの長さはキーによって様々です。
各キーの要素の数字間でそれぞれ、たすき掛けで掛け算し、最も大きいものを採用した上で、
配列の長さで割った値を２つのキー間の値として出力します。

これを大規模なデータセットで実行することを実現したいです。
[関連する前回の質問](https://teratail.com/questions/139409)

### 発生している問題・エラーメッセージ
小規模なデータセットでは問題なく実行できますが、
このコードで、データセットのキーの数が大規模（例えば3万など）な場合、
１つのキーに対してたすき掛けの計算で比較する対象も膨大になるため、
現行のコードのまま実行すると膨大な時間がかかってしまいます。

そこで、並列処理を行うために、以下のコードを書いて、
辞書のキー別に平行で実行しようとしています。
現在のコードではキー別に実行する方法がわからないため、まず、全ての処理を３つのスレッドで平行して行う形式になっていますが、それでも以下のエラーが出てしまっている状況です。

```
#３つのスレッドで同じエラーが出ている状況です
Exception in thread Thread-8:
Traceback (most recent call last):
  File "/Users/username/anaconda/lib/python3.6/threading.py", line 916, in _bootstrap_inner
    self.run()
  File "/Users/username/anaconda/lib/python3.6/threading.py", line 864, in run
    self._target(*self._args, **self._kwargs)
TypeError: 'dict' object is not callable

Exception in thread Thread-6:
Traceback (most recent call last):
  File "/Users/username/anaconda/lib/python3.6/threading.py", line 916, in _bootstrap_inner
    self.run()
  File "/Users/username/anaconda/lib/python3.6/threading.py", line 864, in run
    self._target(*self._args, **self._kwargs)
TypeError: 'dict' object is not callable

Exception in thread Thread-7:
Traceback (most recent call last):
  File "/Users/username/anaconda/lib/python3.6/threading.py", line 916, in _bootstrap_inner
    self.run()
  File "/Users/username/anaconda/lib/python3.6/threading.py", line 864, in run
    self._target(*self._args, **self._kwargs)
TypeError: 'dict' object is not callable
```

### 該当のソースコード

```python
def compute(data, output):
    for alph, nums in data.items():
        avg = {}
        my_list = data[alph]
        for target_alph, target_nums in data.items():
            target_list = data[target_alph]
            if alph == target_alph:
                continue
            max_nums = []

            for i in my_list:
                max_num = 0
                for j in target_list:
                    result = i * j
                    if result is not None and result > max_num:
                        max_num = result
                max_nums.append(max_num) 
            avg[target_alph] = sum(max_nums) / len(max_nums)
            output[alph] = avg
    return output
    
data = {
    'A':[1, 3, 5, 2, 1, 8, 9],
    'B':[9, 4, 3], 
    'C':[8, 5, 5, 6, 1]
}

output = {}

compute(data, output)

thA = threading.Thread(target=compute(data, output)) #data['A']
thB = threading.Thread(target=compute(data, output))#data['B']
thC = threading.Thread(target=compute(data, output)) #data['C']

thA.start(); print ('A started.')
thB.start(); print ('B started.')
thC.start(); print ('C started.')

thA.join(); print ('A completed.')
thB.join(); print ('B completed.')
thC.join(); print ('C completed.')
```

### 試したこと
試したことは、関数化した計算部分のコードと並列処理に関する簡単なコードです。
これらを組み合わせる段階でつまづいています。

関数化した計算部分のコード
```python
def compute(data, output):
    for alph, nums in data.items():
        avg = {}
        my_list = data[alph]
        for target_alph, target_nums in data.items():
            target_list = data[target_alph]
            if alph == target_alph:
                continue
            max_nums = []

            for i in my_list:
                max_num = 0
                for j in target_list:
                    result = i * j
                    if result is not None and result > max_num:
                        max_num = result
                max_nums.append(max_num) 
            avg[target_alph] = sum(max_nums) / len(max_nums)
            output[alph] = avg
    return output
    
data = {
    'A':[1, 3, 5, 2, 1, 8, 9],
    'B':[9, 4, 3], 
    'C':[8, 5, 5, 6, 1]
}

output = {}

compute(data, output)
```
出力
```
{'A': {'B': 37.285714285714285, 'C': 33.142857142857146},
 'B': {'A': 48.0, 'C': 42.666666666666664},
 'C': {'A': 45.0, 'B': 45.0}}
```


[並列処理に関する簡単なコード](https://uxmilk.jp/21092)
```python
import threading
 
def compute():
    x = 0
    times = 2 ** 26
    while x < times:
        x += 1
 
th1 = threading.Thread(target=compute)
th2 = threading.Thread(target=compute)

th1.start(); print '1 started.'
th2.start(); print '2 started.'

th1.join(); print '1 completed.'
th2.join(); print '2 completed.'
```


### 補足情報（FW/ツールのバージョンなど）
Python3.6

Pythonのマルチスレッド処理に関するエラー

pythonのtwintを使ってtwitterをスクレイピングするプログラムを実行しています。
1000tweetずつスクレイピングして、jsonファイルとして出力させる関数を5つfor文で回す仕組みです。
1つの関数の処理が終わるのを待たずsleep(5)で次の関数を走らせたいので、今回threadingを採用してみました。
途中まではうまくいくんですが、最初の方でシャットダウンしてしまいます。
ご教示お願いいたします。

```python
import twint
from datetime import datetime
import shutil
import time
import threading

def scraping(n):

    def gettweet(n):
        nowdate = datetime.now()
        strdate = "{0:%Y-%m-%d %H:%M:%S}".format(nowdate)
        c = twint.Config()
        c.Limit = 1000
        c.Search = 'lang:ja'
        c.Store_json = True
        namedate = "{0:%Y%m%d%H%M%S}".format(nowdate)
        strfilename = 'result' + namedate + '_' + str(n) + '.json'
        c.Output = strfilename
        twint.run.Search(c)
        return strfilename

    while True:
        filename = gettweet(n)
        shutil.move(filename, 'temp/')

for i in range(1, 6):
    sc = threading.Thread(target=scraping, args=(i,))
    sc.start()
    time.sleep(5)

```
エラー内容
```ここに言語を入力
RuntimeError: cannot schedule new futures after shutdown
```

やりたいこと
scraping(1)→無限ループ
処理待たずにscraping(2)→無限ループ
処理待たずにscraping(3)→無限ループ
処理待たずにscraping(4)→無限ループ
処理待たずにscraping(5)→無限ループ

pythonでthreadingを使って無限ループの関数を並行処理させたいが途中でシャットダウンする

#concurrent.futuresを用いてマルチプロセスを行い、その際プロセス間で変数の共有を行いたいです。

threadingやTreadPoolExecutorを用いたマルチスレッドでは実現できましたが、
ProcessPoolExecutorの使い方がわかりませんでした。
[リンク先](https://qiita.com/t_okkan/items/4127a87177ed2b2db148)なども調べてみた結果、マルチプロセスではグローバル変数を用いても、プロセス間で値が共有されないことはわかりましたが、value,arrayをどのように使えばよいか理解できませんでした。
```python3
import concurrent.futures
import time
 
a = 0


def func1():
    print("[1]スタート")
    time.sleep(5)
    print("5秒経過")
    global a
    a = 1
           
def func2():
    print("[2]スタート")
    while True:
        if (a == 1):
            print("値の共有を確認")
            break
                

if __name__ == "__main__":

    with concurrent.futures.TreadPoolExecutor(max_workers=2) as executor:
        executor.submit(func1)
        executor.submit(func2)
```

上記のコードはマルチスレッドで実際に動かすことができたものです。
（細かい処理は省略して、変数の値を共有できたか確認する部分のみにしています）

func1とfunc2をマルチプロセスで動かし、値を共有するにはどのようにコードを書けばよいでしょうか。
よろしくお願いいたします。

[Python]マルチプロセスでメモリ共有を行いたい

### 前提・実現したいこと
Pandas.Dataframeで前の行の値を使って、行の値を変更したい

### 発生している問題・エラーメッセージ
以下のようなPandas.Dataframeのデータがあります。
各行はそのTimeの時点におけるx,y,zの位置を表しています。(Timeはmsec,xyzはmm)

    Time            x           y           z
0      0  1950.385254 -114.936646  845.404541
1    504  1950.385254 -114.936676  845.404419
2   1832  1950.385376 -114.936737  845.404541
3   1976  1950.389038 -114.934784  845.401611
4   1984  1950.414795 -114.921631  845.382813
5   1992  1950.484375 -114.885681  845.331421
6   2000  1950.619995 -114.815666  845.231262
7   2008  1950.843750 -114.700241  845.066101
8   2016  1951.177246 -114.528023  844.820007
9   2024  1951.642944 -114.287712  844.475952
10  2032  1952.261841 -113.967934  844.018433
11  2040  1953.056641 -113.557175  843.430725
12  2048  1954.048828 -113.044235  842.696533
13  2056  1955.259888 -112.417793  841.799194
14  2064  1956.711426 -111.666199  840.722046
15  2072  1958.424561 -110.778175  839.448792
16  2080  1960.421387 -109.742630  837.962463
17  2088  1962.721436 -108.547462  836.246277
18  2096  1965.346558 -107.182030  834.282959
19  2104  1968.317383 -105.634575  832.055420
20  2112  1971.652832 -103.893509  829.545898
21  2120  1975.370239 -101.949677  826.739685

これをうまいこと処理して、前の行との
時間の差分
位置の差分(（x0-x1) ** 2 + （y0-y1) ** 2 + （z0-z1) ** 2 )　** 0.5
位置の差分 / 時間の差分を求めたいです。 

### サンプルのソースコード

```Python
import pandas as pd

def length(pos1,pos2):
    ans = ((pos1.x - pos2.x) **2 + (pos1.y - pos2.y) **2 + (pos1.z - pos2.z) **2)** 0.5
    return ans

df = pd.read_excel('test2.xlsx')
lastvar = 0
df['df_time'] = 0
df['len'] = 0.0
df['spd'] = 0.0

for item in df.itertuples():
    if (hasattr(lastvar, 'Time')):
        diff = item.Time - lastvar.Time
        len =  length(item,lastvar)
        df.at[item.Index, 'df_time'] = diff
        df.at[item.Index, 'len']    = len
        df.at[item.Index, 'spd']    = len / diff * 1000
        
    lastvar = item
print(df)
```
### 結果
    Time            x           y           z  df_time       len         spd
0      0  1950.385254 -114.936646  845.404541        0  0.000000    0.000000
1    504  1950.385254 -114.936676  845.404419      504  0.000126    0.000249
2   1832  1950.385376 -114.936737  845.404541     1328  0.000183    0.000138
3   1976  1950.389038 -114.934784  845.401611      144  0.005080    0.035280
4   1984  1950.414795 -114.921631  845.382813        8  0.034493    4.311665
5   1992  1950.484375 -114.885681  845.331421        8  0.093675   11.709316
6   2000  1950.619995 -114.815666  845.231262        8  0.182556   22.819506
7   2008  1950.843750 -114.700241  845.066101        8  0.301110   37.638782
8   2016  1951.177246 -114.528023  844.820007        8  0.448822   56.102707
9   2024  1951.642944 -114.287712  844.475952        8  0.626895   78.361925
10  2032  1952.261841 -113.967934  844.018433        8  0.833436  104.179465
11  2040  1953.056641 -113.557175  843.430725        8  1.070435  133.804352
12  2048  1954.048828 -113.044235  842.696533        8  1.336630  167.078779
13  2056  1955.259888 -112.417793  841.799194        8  1.632272  204.034050
14  2064  1956.711426 -111.666199  840.722046        8  1.957576  244.697004
15  2072  1958.424561 -110.778175  839.448792        8  2.311838  288.979722
16  2080  1960.421387 -109.742630  837.962463        8  2.696079  337.009862
17  2088  1962.721436 -108.547462  836.246277        8  3.108689  388.586106
18  2096  1965.346558 -107.182030  834.282959        8  3.551097  443.887085
19  2104  1968.317383 -105.634575  832.055420        8  4.022729  502.841118
20  2112  1971.652832 -103.893509  829.545898        8  4.522635  565.329433
21  2120  1975.370239 -101.949677  826.739685        8  5.047022  630.877725

### 試したこと

添付のコードのように、For文でかけるといえばかけるのですが、なんだかしっくり来ないというか、
スマートでないですし、前の値をループで保存しているので、並列化等ができないと思っています。
このコードをスマートに書き換えていただけないでしょうか？



Python初めて２日程度なので、Pythonらしく直していただいて構いません。

### 改良後のソースコード
lehshellさんから改良案を頂き、そのあたりで自分で調べた結果もふまえて書き換えたコードを以下においておきます。
shiftメソッドの他に、diffでもできるみたいです。


```Python
import pandas as pd

def length(pos1,pos2):
    ans = ((pos1.x - pos2.x) **2 + (pos1.y - pos2.y) **2 + (pos1.z - pos2.z) **2)** 0.5
    return ans

def length2(diffx,diffy,diffz):
    ans = (diffx ** 2 + diffy ** 2 + diffz ** 2) ** 0.5
    return ans

def method1(): #改良前
    df = pd.read_excel('test2.xlsx')
    lastvar = 0
    df['df_time'] = 0
    df['len'] = 0.0
    df['spd'] = 0.0

    for item in df.itertuples():
        if (hasattr(lastvar, 'Time')):
            diff = item.Time - lastvar.Time
            len =  length(item,lastvar)
            df.at[item.Index, 'df_time'] = diff
            df.at[item.Index, 'len']    = len
            df.at[item.Index, 'spd']    = len / diff * 1000
        lastvar = item
    print(df)

def method2(): #改良案1
    df = pd.read_excel('test2.xlsx')
    df['df_time'] = (df['Time'] - df['Time'].shift(1)).fillna(0)
    df['len'] = length(df, df.shift(1)).fillna(0)
    df['spd'] = (df['len'] / df['df_time'] * 1000).fillna(0)
    print(df)

def method3(): #改良案2
    df = pd.read_excel('test2.xlsx')
    df['df_time'] = df['Time'].diff().fillna(0)
    df['len'] = length2(df["x"].diff(),df["y"].diff(),df["z"].diff()).fillna(0)
    df['spd'] = (df['len'] / df['df_time'] * 1000).fillna(0)
    print(df)


method1()
method2()
method3()
```

Python:Pandas.Dataframeで前の行の値を使って、行の値を変更したい

### 前提・実現したいこと

PySimpleGUIでスレッド処理にてカウント実行しながらwindowの画像表示をループさせたい。

①下記デスクトップアプリに横棒の画像を表示させているのが初期状態で、Startをクリックすると、パラパラアニメとして横棒が下に移動していきます。（1～5.pngを用意しています。）

②上記パラパラが動きつつ、別スレッドでカウントwhileメソッドが動き続けます。

![イメージ説明](4957ce0c033d4c7617b0f5e94bc2bce1.png)

### 環境
OS:windows10
language:Python3.7
Library:PySimpleGUI,threading

### 発生している問題・エラーメッセージ

トラブル１：スレッドが正常に実行できない。

![イメージ説明](25b5fc1a4d40e990ade98d546b0e7cb4.png)
```
AttributeError: 'str' object has no attribute 'window'
```

### 該当のソースコード

```python
import threading
import time
import sys
import PySimpleGUI as sg

def play_count(fname):
    str_num = 0
    while True:
        str_num += 1
        time.sleep(1)
        print(str_num)

def play_anime(self):
    n_count = 0
    n_times = 0
    while True:
        # time.sleep(2)
        # n_count += 3
        # print('aaaaaaaa:', n_count)
        # ここはなんとか1.png 2.png 3.png 4.png 5.pngを代入しようとした
        if n_count == 5:
            n_times += 1
        if n_count > 5:
            if n_count % 5 == 0:
                n_times += 1
        n_count += 1
        n_count_last = n_count - 5 * n_times

        print('./' + str(n_count_last) + '.png')

        self.window['-image_canvas-'].Update(filename = './' + str(n_count_last) + '.png')



if __name__ == '__main__':
    #ウインドウの表示、設定
    sg.theme('BluePurple')
    layout = [
        [sg.Text('処理の実行、変更、停止を行います:'),sg.Text(size=(15,1), key='-OUTPUT-')],
        [sg.Button('Start'),sg.Button('exchange')],
        [sg.Image('./1.png', key='-image_canvas-')]
        ]
    window = sg.Window('Pattern 2B', layout)

     #スレッド処理のインスタンス生成
    # = Receive(window)
    def startEvent(event):#スタートボタン押下時の処理
        #r.ROOP = True
        #r.start()

        DATA = "arg"
        thread3 = threading.Thread(target=play_count, args=[DATA])
        thread4 = threading.Thread(target=play_anime, args=[DATA])

        thread3.start()
        thread4.start()

        thread3.join()
        thread4.join()


    n_count = 0
    n_times = 0
    #rotation_flag = False
    while True:
        event , values = window.read()
        #ボタンの処理内容
        if event == 'Start':
            window['-OUTPUT-'].update('実行中')
            # rotation_flag = True
            startEvent(event)

        if event == 'exchange': # UP ボタンを押したら画像切り替え
            
            if n_count == 5:
                n_times += 1
            
            if n_count > 5:
                if n_count % 5 == 0:
                    n_times += 1
            
            n_count += 1
            n_count_last = n_count - 5 * n_times
            window['-image_canvas-'].Update(filename = './' + str(n_count_last) + '.png')

        # if rotation_flag == True:
        #     time.sleep(3)
        #     print('rotation_flag if 内部')
        #     if n_count == 5:
        #         n_times += 1
            
        #     if n_count > 5:
        #         if n_count % 5 == 0:
        #             n_times += 1
            
        #     n_count += 1
        #     print('n_count:', n_count)
        #     n_count_last = int(n_count) - 5 * n_times
        #     print('n_count_last:', n_count_last)
        #     #self.window['-image_canvas-'].update(filename = './2.png')
        #     window['-image_canvas-'].Update(filename = './' + str(n_count_last) + '.png')
```

### 試したこと

ソースコードの一番下の場所で今コメントアウトになっているところなのですが、そこでwindowを更新すればよいのではと思い試しました。当初、play_animeメソッド内で windowのupdateをいくらしても、windowsが更新されないのであれば、意味がないのだと思い、この更新メソッドを一番下に記載しました。

ところが、startEventメソッドに行き、スレッド実行２つが始まったら、もはや今のソースの箇所は読み込まれず、結局実現できませんでした。何かアドバイス頂けないでしょうか。よろしくお願いいたします。

### 2021/12/8 20:33 追記
ppaulさんの方法を試したところ確かに該当のエラーはなくなりました。
新しいエラーが出てしまいました。
![イメージ説明](5a606e6f43a1e75e8da69459bc22fa7e.png)

PySimpleGUIでスレッド処理にてカウント実行しながらwindowの画像表示をループさせたい。

### 前提・実現したいこと

5つの関数（メインを含めると6つ）を並列で行いたいです。
CPU情報を調べてみたところ4個のコア、4個のロジカルプロセッサと記載されていて、threadで実装しようとするとスレッド数が足りないように思います。
調べたところmultiprocessingとjoblibというモジュールではスレッドではなくコアで並列処理を行うとなっていたのですが、threadとmultiprocessingかjoblibを同時に行っても問題ないでしょうか？

### 発生している問題・エラーメッセージ

```
エラーメッセージ
```

### 該当のソースコード

```python
from threading import Thread
from multiprocessing import Pool

def func_1():
    while True:
        ・・・   # とある処理

def func_2():
    while True:
        ・・・   # とある処理

def func_3():
    while True:
        ・・・   # とある処理

def func_4():
    while True:
        ・・・   # とある処理

def func_5():
    while True:
        ・・・   # とある処理

if name == "__main__":
   Thread(target=func_1).start()
   Thread(target=func_2).start()
   Thread(target=func_3).start()

   pool = Pool(2)
   pool.apply_async(func_4)
   pool.apply_async(func_5)

   while True:
       time.sleep(60)
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。