常連

### 前提・実現したいこと

データセットがキーのアルファベット記号と要素の数字からなる辞書型で与えられており、
数字はリストに格納されています。リストの長さはキーによって様々です。
各キーの要素の数字間でそれぞれ、たすき掛けで掛け算し、最も大きいものを採用した上で、
配列の長さで割った値を２つのキー間の値として出力します。

これを大規模なデータセットで実行することを実現したいです。
[関連する前回の質問](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のマルチスレッド処理に関するエラー

# 状況
自作のモジュール内で`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のコア/スレッド数を超えたスレッドを指定するということはどういうこと？

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を使って無限ループの関数を並行処理させたいが途中でシャットダウンする

### 実現したいこと

pythonのmultiprocessingを動かず止まってしまいます.

```main.py
from torch.multiprocessing import Manager, Pool, Process
from model import model
from data import data
if __name__=='__main__':
    def matmul(inputs):
        customer_x, item_x = inputs
        customers = torch.arange(customer_x.size(0))
        rating_all = []
        for batch_users in tqdm(minibatch(customers, batch_size=TEST_BATCH_SIZE)):
            rating = customer_x[batch_users] @ item_x.T
            rating_all.append(rating)
        rating_all = torch.cat(rating_all)
        return rating_all
    data = data()
    model = model()
    customer_x, item_x = model.getUsersRating()
    process_num = 8

    p = Pool(process_num)
    customer_per_process = customer_x.size(0)//process_num
    xs = [(customer_x[customer_per_process*i:customer_per_process*(i+1)], item_x) if i!=process_num-1 else \
        (customer_x[customer_per_process*i:], item_x) for i in range(process_num)]

    rating_all = p.map(matmul, xs)

```

### 前提

行列計算をmultiprocessingを用いて並列計算しようとしています. しかし, 上記のmain.pyを実行してもPool.map()のとこで計算が止まってしまいます. jupyter notebookではPool.map()が動くことを確認したのですが, pythonスクリプトから実行すると計算が止まってしまいます. __name__=='__main__'からの実行もしているので, なぜ止まってしまうのかわからず困っている状況です.



### 試したこと
通常のmultiprocessingやPoolも試しましたが同様に止まってしまいました. また, matmulの位置は__name__=='__main__'の前後のどちらでも止まってしまいました.
torch.multiprocessing.get_start_method()の結果はjupyter, スクリプト共にforkでした

### 補足情報（FW/ツールのバージョンなど）

torch 2.0.0
python 3.10


python multiprocessingが動かない

### 前提・実現したいこと

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の画像表示をループさせたい。

### 前提・実現したいこと
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で前の行の値を使って、行の値を変更したい

swiftで非同期処理、マルチスレッドを学習しているのですが、概念というかいまいち仕組みについてピンときません。
私の考えがずれている可能性があるので間違っている箇所があればご指摘いただきたいです。

swiftで
①DispatchQueue.mian.async
②DispatchQueue.mian.sync
③DispatchQueue.global.async
④DispatchQueue.global.sync

①② と　③④の違いはメインスレッドで行うか、サブスレッドで行うかの違い。

①　と　② の違いは並列で行うか直列で行うか

③ と　④　の違いも並列で行うか。直列で行うか。

とある本では通信に関する処理は自動でサブスレッドで非同期処理（並列）で行われると書いてありました。
UIに関する処理はメインスレッドで。

つまり、API通信や、Firebaseなどから情報を取得する際はサブスレッドで並列処理が自動で行われているということになります。

```swift
import UIKit
class ViewController:UIViewController{
    var label:UITextView!
    
    override func viewDidLoad(){
        super.viewDidLoad()
        label=UITextView()
        label.text="ロード中"
        label.frame=CGRect(x:10,y:30,width:self.view.frame.width - 20,height:300)
        self.view.addSubview(label)
        
        let unit = "metric"
        let appId = "ebaf2eeae4e09f63ccdcb4e59e5fac68"
        let city = "Tokyo"
        let urlString="https://api.openweathermap.org/data/2.5/weather?units=(unit)&APPID=(appId)&q=(city)"
        let url=URL(string:urlString)!
        var request=URLRequest(url:url)
        request.httpMethod="GET"
        
        let task = URLSession.shared.dataTask(with:request){(data,response,error) in
            guard let data = data else{ return }
            do {
                let object = try JSONSerialization.jsonObject(with:data,options:[]) as? [String:Any]
                print(object)
　　　　　　　　　　//①メインスレッドで非同期処理？
                DispatchQueue.main.async{
                    self.label.text = object?.description
                    self.label.sizeToFit()
                }
            } catch let e{
                print(e)
            }
        }
        task.resume()
    }
    override func didReceiveMemoryWarning(){
        super.didReceiveMemoryWarning()
    }
}
```

ある本のソースコードです。天気のwebAPIへリクエストを送り、そのレスポンス（json）を表示するプログラムです。
データの取得時に①の処理がありますが、このロジックはどのように動いているのかが理解できません。
通信に関するものはサブスレッドで行われるらしいですが具体的にどこからどこまでがサブスレッドで行われているのか。
なぜ、メインスレッドに処理を渡すことでこのソースコードは応答性の向上が見込めるのか。
結局レスポンスが返ってきた瞬間にメインスレッドの並列の処理に即処理を渡すコードを書くことですぐに反映されるからってことでいいんですかね。メインスレッドは直列で他の処理を行ったりするから並列でUIの更新をする的な？

例えば、逆に

```swift
DispatchQueue.main.async{
                    self.label.text = object?.description
                    self.label.sizeToFit()
                }
```
の処理を外に放り出すとどのようなロジックで応答性に差が出るのでしょうか