常連

### 前提・実現したいこと

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/ツールのバージョンなど）

ここにより詳細な情報を記載してください。

pythonでの並列処理でスレッド数が足りない

### 実現したいこと
外部のexeファイルと文字列の入出力のやり取りをするpythonのコードにconcurrent.futuresを使えるようにして関数をマルチスレッド化したい。スレッドの最大数を制限し、終了したスレッドが発生次第スレッドをまた動かすことを繰り返したいです。

### 前提
subprocess.Popenを用いて、外部のexeファイルと文字列の入出力のやり取りをするプログラムを書いています。外部のexeは詰将棋を解答するプログラム（脊尾詰）で、こちらのURLでダウンロードしたものをそのまま使っています。
http://panashogi.web.fc2.com/seotsume.html
私が書いているexeファイルは、usiプロトコルに従って文字列の入出力を行います。
http://shogidokoro.starfree.jp/usi.html#ProblemExample

参考URLの要点だけを説明すると、私のプログラムで行うexeへの入出力とその説明は以下の通りです。
usi\n：詰将棋エンジン起動。これをexeへ入力すると、usiokを含む文字列がexeから出力される
setoption name USI_Hash value 512\n：詰将棋エンジンに関する設定を変更
setoption name Do_YoTsume_Search value false\n：詰将棋エンジンに関する設定を変更
isready\n：詰将棋解答開始前の準備。これをexeへ入力すると、readyokを含む文字列がexeから出力される
usinewgame\n：これをexeへ入力することで、exeは詰将棋盤面の文字列の入力待ち状態に移行する。

position sfen…\n：詰将棋の盤面をexeへ入力。
go mate infinite\n：これをexeへ入力することで、exeは入力された詰将棋を解答し始める。結果が出ると'checkmate'を含む文字列を出力する。終了すると盤面の入力待ち状態に戻り、再び"position sfen..."コマンドを待つ状態になる。


私のコードでは、1つ目の関数(funcX)でusinewgame\nまでexeに入力してexeを盤面の入力待ち状態に移行させた後、2つ目の関数(funcY)で詰将棋の盤面をexeに入力して解答結果を得る、という構成になっていて、1回だけfuncXを実行してその後はfuncYを繰り返し実行しています。スレッドの最大数を制限しつつ、funcXとfuncYをマルチスレッド化(orマルチプロセス化)し、複数の詰将棋を複数の詰将棋解答exeに入力して、解答が終了したものから解答結果を得ていくようにしたいです。あるスレッドで関数Yが終了したら、スレッドをまた動かして別の盤面を指定したfuncYを実行して…ということをやりたいです。


### 

```Python
import subprocess
import keyboard
import concurrent.futures

def main():
    #list1は、詰将棋の盤面を表現した文字列を集めてリストにしたもの。非本質なので気にしないでください
    list1=['position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b R2G2Nr2b2g4s3l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RGS2NPr2b3g3s3l14p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RSNLr2b4g3sn2l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RSNPr2b4g3sn3l14p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RSN2Pr2b4g3sn3l13p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RBSNrb4g3sn3l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RBSNLrb4g3sn2l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b RBGNrb3g4sn3l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b R2BNr4g4sn3l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b B2GS2rb2g3s2n3l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b BG2SL2rb3g2s2n2l15p 1\n',
           'position sfen 7nl/7k1/9/5Np1p/9/5+P3/9/9/9 b 2B3S2L2r4gs2nl15p 1\n',
           'position sfen 2n3p2/5+r1p1/7+pk/3p5/3+p5/9/9/6L2/9 b R4GNP2b4s2n3l12p 1\n']

    file_to_path1="SeoTsume_1.exe"#exeファイルのパス
    file_to_path2="SeoTsume_2.exe"#exeファイルのパス2
    proc1=subprocess.Popen(file_to_path1,stdin=subprocess.PIPE,stdout=subprocess.PIPE)#サブプロセスを起動しておく。exeが起動される
    proc2=subprocess.Popen(file_to_path2,stdin=subprocess.PIPE,stdout=subprocess.PIPE)#マルチスレッド用にexeをコピーした別のexeを用意して起動。

    funcX(proc1)#funcXは最初に一度だけやっておかなければならない入出力のやり取りの関数
    funcX(proc2)
    num=0
    while(num<len(list1)-1):
        with concurrent.futures.ProcessPoolExecutor(max_workers=2) as executor:#マルチスレッド化したい
            executor.submit(funcY,proc1,list1[num]) #funcYの引数として、funcXを介して盤面の入力待ち状態になったPopenオブジェクトと、盤面の文字列list1[num]を指定する
            executor.submit(funcY,proc2,list1[num+1])
        num+=2

def funcX(proc):#exeファイルを盤面の入力待ち状態に移行させるために最初に一度だけ実行しておく関数
    proc.stdin.write(('usi\n').encode())#pyからexeファイルへ文字列"usi\n"を入力
    proc.stdin.flush()#flushは必須

    while True:
        line = proc.stdout.readline().rstrip().decode('utf-8')#exeからpyへ文字列出力を1行ずつ受け取る
        if line == 'usiok':#exeからpyへ"usiok"という文字列が出力された場合、出力の受け取りを中断する。
            print(line)
            break

    proc.stdin.write(('setoption name USI_Hash value 512\n').encode())#pyからexeファイルへ文字列を入力。
    proc.stdin.flush()

    proc.stdin.write(('setoption name Do_YoTsume_Search value false\n').encode())#pyからexeファイルへ文字列を入力。
    proc.stdin.flush()
 
    proc.stdin.write(('isready\n').encode())#pyからexeファイルへ文字列を入力
    proc.stdin.flush()

    while True:
        line = proc.stdout.readline().rstrip().decode('utf-8')#exeからpyへ文字列出力を1行ずつ受け取る
        if line == 'readyok':#exeからpyへ"readyok"という文字列が出力された場合、出力の受け取りを中断する
            print(line)
            break

    proc.stdin.write(('usinewgame\n').encode())#pyからexeファイルへ文字列を入力。ここで、exeファイルが詰将棋の盤面入力待ち状態に移行する。
    proc.stdin.flush()


def funcY(proc,input_cmd):#funcXによって盤面の入力待ち状態に移行したexeファイルに対して、実際に盤面を入力し、exeから解答結果を得る
    print(input_cmd)
    proc.stdin.write(input_cmd.encode())#pyからexeファイルへ文字列を入力。input_cmdは詰将棋の盤面。これをexeに投げる。
    proc.stdin.flush()

    proc.stdin.write(('go mate infinite\n').encode())#pyからexeファイルへ文字列を入力。これによりexeが詰将棋を解き始める。
    proc.stdin.flush()

    while True:#exeが詰将棋解答中。
        line = proc.stdout.readline().rstrip().decode('utf-8')#exeからpyへ文字列出力を1行ずつ取る
        print(line)
        if line[:9]=='checkmate':#exeからpyへ"checkmate"を含む文字列が出力された=詰将棋の解答結果が出たという意味。出力の受け取りを中断し、解答結果を得る
            result=line
            # print(line)
            break
        if keyboard.is_pressed("escape"):#キーボード操作でいつでも中断できる
            break

    return result#詰将棋を解答した結果を返す

if __name__ == "__main__":
    main()
```


### 発生している問題・エラーメッセージ
上に示すコードはfuncXは普通に実行し、funcYだけマルチスレッド化したコードです。funcYの内部にprint文を入れて出力を観察しましたが、funcXが終わった後はfuncY内部のprint文は一切反応せず、少し間があいてプログラムが終了します。
concurrent.futuresを使用しない普通のシングルスレッドのコードなら普通に動作することから、executor.submit()が動作してなさそうです。submit()の引数としてPopenオブジェクトを指定できないのではないかと考えています。

```実行結果
usiok
readyok
usiok
readyok
#本来はここからfuncYでの実行結果が表示されるはずだが…
```

### あり得る疑問点
A.funcXとfuncYを分離させている意味、funcXを1回だけ実行してfuncYを繰り返す処理を行う意味
Q.
funcXは、exeをただの起動状態から盤面の入力待ち状態にする関数。funcYは、盤面の入力待機状態のexeに盤面を入力して解答させ、exeからの結果を待つ関数。
なのでfuncYはfuncXの後でないと動かない。また、上記した通り、funcYを1度実行した後はexeは盤面の入力待機状態に戻るので、funcYを実行した後はfuncXを実行し直さなくてよい。
無視できない程度に時間がかかり、実行回数は最低限にしたいfuncXとfuncYを纏めて繰り返すことはしたくないから、funcXとfuncYを分離させ、funcYだけ繰り返すようにした。

A.funcYの引数として、proc=Popenオブジェクトを指定する理由
Q.
funcXを介した後のPopenオブジェクトの状態（exeの盤面入力待ち状態）を維持したままfuncYに移りたいので、Popenオブジェクトを指定している。
例えば、funcYの引数としてexeのファイルパスを渡し、funcY内でsubprocess.Popen(<path to exe>,stdin=subprocess.PIPE,stdout=subprocess.PIPE)としてexeを起動する方法もあるが、それだとfuncY内で起動したexeをただの起動状態から入力待ち状態に移行させる必要性が出てくる。
それはfuncXとfuncYを纏めて繰り返す処理と同じだが、前述の理由でそれはしたくないです。

### 補足情報（FW/ツールのバージョンなど）
Windows11環境です。

Pythonでスレッド数の上限の範囲内で関数を並行処理する

C言語でのマルチスレッドでのログファイル出力したいと考えています。

以下の方法にて、試みてみましたが、ログを確認するとマルチスレッドの為か、グチャグチャになってしまいます。
排他制御等が必要なのでしょうか？
詳しい方、教示願います。

・7/12 追記
返答遅くなりすいません。

ファイルがグチャグチャというのは、其々のタスクから出力した文字列が混ざったような出力結果ということです。
正確にはマルチスレッドというより、マルチタスクです。
[プラットフォーム]　vxWorks




```ここに言語を入力
#include <stdio.h>
#include <sys/types.h>

FILE *fp;
char filename[] = "sample.log";

void log(void) {
    fprintf(fp, "%s : tid => %d\n", __func__, gettid());
    
　　/*7/12補足漏れ追記 */
    fflush(fp);
}

int main(void) {
    /* ファイルオープン */
    if ((fp = fopen(filename, "a+")) == NULL) {
        fprintf(stderr, "ファイルのオープンに失敗しました．\n");
        return EXIT_FAILURE;
    }

    /*途中簡略 複数スレッド起動して、各スレッドから上記log関数をコールする*/

    /* ファイルクローズ */
    fclose(fp);
}
```

C言語でマルチスレッドでのファイル出力

anaconda promptからpython aaa.pyで直接動かしてます
aaa.pyは一度起動すると結構時間がかかるので　途中で停止させたいとこがあります
しかしマルチスレッドだと　ctrl＋ｃでは停止させれません　
調べても　コード内でスレッドを停止させる物しかでてきません　すべてのスレッドを手動で一度に中断したいです

python でマルチスレッドのプログラムを途中で停止する方法はりませんか？
わかる人教えてください

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/254257)

C#でUSB接続でシリアル通信を行うWindowsアプリを作成しています。
同時に複数のデータが来た場合に対応するために、マルチスレッドに変更したいと思っております。
が、恥ずかしながらマルチスレッドの実装を行ったことがなく、ググってもイマイチだったため、
皆さまのお力を借りたいと思いました。
現状は、データが2回来て正常なデータとするため、同時に来た場合にさばけない状態となっています。
（先勝ちな状態です。）

データの一連の流れは、下記になります。
①データ受信[1回目]
②データ受信[2回目] ← ここでデータ確定
③受信データをAPI経由でDBへ格納
④戻り値を受信元へ送信

### 該当のソースコード

```C#
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.IO.Ports;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Linq;

namespace App
{
	public partial class Form : Form
	{
		private SerialPort serialPort;

		// APIパス
		private const string API_PATH = @"http://XXXXX";

		private int			iRetry = 1;
		private int			iSeq = 0;
		private string		sBefData = string.Empty;
		private string		sData = string.Empty;
		private string		sVal1 = string.Empty;
		private string[]	sReturnVal = new string[2];
		private bool		bFirst = true;

		readonly string sPath = AppDomain.CurrentDomain.BaseDirectory;
		private string sFilePathBefore;
		string sLogFolder = "LogFile";
		private bool bSuccess = false;

		public Form()
		{
			InitializeComponent();
		}

		/// <summary>
		/// フォームロード時イベント
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void Form_Load(object sender, EventArgs e)
		{
			string[] ports = SerialPort.GetPortNames();
			foreach (string port in ports)
			{
				this.cmbSerials.Items.Add(port);
			}
			if (0 < this.cmbSerials.Items.Count)
			{
				this.cmbSerials.SelectedIndex = 0;
			}
		}

		/// <summary>
		/// 接続ボタン押下時イベント
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void btnConnect_clicked(object sender, EventArgs e)
		{
			if (this.cmbSerials.SelectedItem != null && this.serialPort == null)
			{
				// COMポートをOPEN
				serialPort = new SerialPort();
				serialPort.DataReceived += new SerialDataReceivedEventHandler(SerialPort1_DataReceived);
				serialPort.PortName  = this.cmbSerials.SelectedItem.ToString();
				serialPort.BaudRate  = 19200;
				serialPort.DataBits  = 8;
				serialPort.Parity    = Parity.None;
				serialPort.StopBits  = StopBits.One;
				serialPort.Encoding  = Encoding.UTF8;

				try
				{
					serialPort.Open();
				}
				catch (Exception ex)
				{
				}
			}
		}

		/// <summary>
		/// データ受信時イベント
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void SerialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
		{
			if (serialPort != null && serialPort.IsOpen)
			{
				try
				{
					// 受信データを読み込む
					SerialPort sp = (SerialPort)sender;
					string sChildData = sp.ReadExisting();

					if (sChildData.Length == 2 && bFisrst)
					{
						sVal1 = sChildData;
					}
					else
					{
						sData = sChildData;
						if (bFirst) {
							return;
						}
					}

					if (!string.IsNullOrEmpty(sData) && !string.IsNullOrEmpty(sVal1))
					{
						if (0 < sData.Length) {
							if (string.IsNullOrEmpty(sBefData) || sBefData != sData)
							{
								var parameters = new Dictionary<string, string>()
								{
									// APIへ渡すデータセット
								};
								var content = new FormUrlEncodedContent(parameters);

								try {
									sReturnVal = GetResponseAPI(API_PATH, content);
									sBefData = sData;
									bSuccess = true;
								} catch {
									bSuccess = false;
								}

								if (bSuccess)
								{
									if (0 < sReturnVal.Length)
									{
										try
										{
											// 送信元へデータ送信
										}
										catch (Exception ex)
										{
										}
									}
									else
									{
										this.iRetry = 1;
									}
								}
								sData = string.Empty;
								sVal1 = string.Empty;
								sReturnVal = new string[]{ };
							}
						}
					}
				}
				catch (Exception ex)
				{
				}
			}
		}

		/// <summary>
		/// 終了ボタン押下時イベント
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void btnFinish_clicked(object sender, EventArgs e)
		{
			if (serialPort != null && serialPort.IsOpen)
			{
				serialPort.Close();
				serialPort = null;
			}
		}

		/// <summary>
		/// APIをたたいてレスポンスを取得
		/// </summary>
		private string[] GetResponseAPI(string sApiUrl, FormUrlEncodedContent sContent)
		{
			string[] sVal = new string[2];
			var task = Task.Run(() => {
				return HttpPost(sApiUrl, sContent);
			});
			string response = task.Result;
			JArray data = (JArray)JsonConvert.DeserializeObject(response);
			foreach (JObject obj in data)
			{
				JValue did = (JValue)obj["device_id"];
				JValue val = (JValue)obj["return_data"];
				sVal[0] = (string)did.Value;
				sVal[1] = (string)val.Value;
			}

			return sVal;
		}

		/// <summary>
		/// APIをPOSTする
		/// </summary>
		/// <param name="sUrl">APIのURL</param>
		/// <param name="fContent">引数をエンコードしたもの</param>
		/// <returns></returns>
		async public Task<string> HttpPost(string sUrl, FormUrlEncodedContent fContent)
		{
			var client = new HttpClient();
			var response = await client.PostAsync(sUrl, fContent);
			return await response.Content.ReadAsStringAsync();
		}
	}
}

```

### 補足情報（FW/ツールのバージョンなど）

Windows 10
Visual Studio 2017
c#／Windows Form／.Net Framewrok 4.7.1

シリアル通信でマルチスレッド化（同時受信データを処理したい）

### 前提・実現したいこと
arduino側より電圧値を送信し、cvsファイルに書き込むプログラムを書いています。
[開始]ボタンで測定値読み見込みはじめ[終了]ボタンで測定を終了させます。
[終了]ボタンを押すとdialogは消えて、再度起動すれば測定可能ですが、[終了]ボタンで以下エラーメッセージが出力されます。


### 発生している問題・エラーメッセージ
[終了]させると、下記エラーメッセージが出力されます。
動作そのものは、問題なく動いているようです。
これを解消させるためにはどのようにすればよろしいでしょうか?

エラーメッセージ
Exception in thread Thread-7:
Traceback (most recent call last):
  File "C:\ProgramData\Anaconda3\lib\threading.py", line 926, in _bootstrap_inner
    self.run()
  File "C:\ProgramData\Anaconda3\lib\threading.py", line 870, in run
    self._target(*self._args, **self._kwargs)
  File "D:/Python/STAIC-SK1000/STAIC-SK1000_04.py", line 39, in serial_data_recv
    fl_line = float(w_line)
ValueError: could not convert string to float:

### 該当のソースコード

```python3.7

import tkinter as tk
import datetime
import serial
import time
import threading

ser = serial.Serial("COM6",9600)

def serial_data_recv():
    global stop_flag
    stop_flag = True

    
     # 通信最初の50要素から読み(通信のゴミを読み飛ばす) 
    print("通信バッファクリア中……")
    for i in range(50):
       ser.readline().rstrip()                   #\r\n削除

    print("測定開始")       
    
    f_now = datetime.datetime.now()                    #現在時刻取得
    #　ファイル名を時刻.csvに設定
    recv_data = f_now.strftime('%Y%m%d_%H%M') + ".csv"
    with open(recv_data,'w') as f:                    #ファイルオープン
        while True:
            if stop_flag == False:
                break
            else:
                line = ser.readline().rstrip()         #\r\n削除
                s_line = str(line)                     #文字列化
                w_line = s_line.strip("b'")            #受信文字から"b、'"を削除

                fl_line = float(w_line)
                SEN_OUT = (fl_line * 5.0)/1023	　　　# 0-5vに変換
                SEN_OUT2 = round(SEN_OUT,2)            
                now = datetime.datetime.now()             #現在時刻取得
            
                #ファイルフォーマットを整えて書き込み
                file_time0 = now.strftime('%H')
                f.write(str(file_time0))
                f.write(":")
                file_time1 = now.strftime('%M')
                f.write(str(file_time1))
                file_time2 = now.strftime('%S')
                f.write(":") 
                f.write(str(file_time2))
                f.write(",")
                f.write(str(SEN_OUT2))                    #受信データ書き込み
                f.write(",")
                f.write("V")
                f.write(",\n")                          #","と改行挿入

                print("  " + (str(SEN_OUT2)) + "  V")

    f.close()
    ser.close()
    print("測定終了") 
    time.sleep(5)
    root.destroy()    

def start():
    global stop_flag
    global thread

    # スレッドが無いなら生成してstart()する
    if not thread:
        thread = threading.Thread(target = serial_data_recv)
        stop_flag = False
        thread.start()
    
def stop():
    global stop_flag
    global thread      

    ser.close()
    root.destroy()    

    # スレッドがある場合停止してjoin()する
    if thread:
        stop_flag = True
        thread.join()
        thread = None


thread = None
 
root = tk.Tk()
root.title("検査  電圧計")
root.geometry("250x220+1000+10")

#thread_1 = threading.Thread(target = start)
#thread_2 = threading.Thread(target = stop)

button1 = tk.Button(root, text = "測定開始", font=("MSゴシック", 14),
        command = start)
button1.place(x = 80, y = 30)

button2 = tk.Button(root, text = "測定終了", font=("MSゴシック", 14),
        command = stop)
button2.place(x = 80, y = 70)

root.mainloop()
```

### 試したこと

ネットで調べましたが、わからないでいます。

### 補足情報（FW/ツールのバージョンなど）
開発ツールは、Windows10でspyder3を使用しています。

python マルチスレッド終了時のエラーメッセージ

以下のようなエラーが度々でてしまうのですが原因はなんなのでしょうか？
```Error
undefined reference t'
/lib/x86_64-linux-gnu/libpthread.so.0: error adding symbols: DSO missing from command lie
collect2: error: ld returned 1 exit status
```

ちなみにコンパイルだけであれば-lpthreadの部分を
-pthreadに変更するとなぜか通ります。
自分の解釈では-lpthread というように記述することによりincludeをした際に 
/usr/lib/-----
を探しにいくことでなにか原因がありErrorがおこっているのか？と思いました。