常連

非同期処理の仕組みは、ググって記事などを読むと同時にタスクを実行する仕組みとありますが、これはマルチスレッドもしくはマルチプロセスを使っている仕組みなのでしょうか？イマイチ理解できなかったので詳細や違いを教えて欲しいです。

■マルチスレッド　1つのプログラム内で同時に処理を実行 
　e.g. PythonでいうThreadPoolExecutor、threading
■マルチプロセス　複数のプロセス(システムリソース)で同時に処理　
   e.g. PythonでいうProcessPoolExecutor

※質問の背景
Blockchainのsolanaは非同期処理によって早いトランザクションスピードを実現しているようですが、その仕組みを研究しています。


非同期処理の仕組みはマルチスレッドもしくはマルチプロセスですか？

こんにちは
現在、GUIがフリーズしないようにSystem.Threading.Thread.Sleep()の代わりに

```ここに言語を入力
public async void SleepAsync(int milliseconds)
{
  await Task.Delay(milliseconds);
}
```
と書いて sleep()の代わりに使っているのですが

```ここに言語を入力
while()
{
  SleepAsync(2000);
  console.WriteLine("待機終了");
}
```
と書いても2秒待たずに、待機終了 と表示されます。
一方で
```ここに言語を入力
while (true)
{
  Task.Run(async () => { await Task.Delay(2000); Console.WriteLine("待機終了"); });
}
```
このように遅延処理？で書くと、最初の一回だけ２秒待機して、そのあとは遅延されません

sleep()をしたいだけなのに一体なにが起こっているのでしょうか・・・？

C# await Task.Delayがうまく動かない

#### 「メインスレッドでの同期XMLHttpRequestは、エンドユーザーエクスペリエンスに悪影響を与えるため、非推奨です。」
この警告って、どうやって消えますか？


---
現在、html css javascript の勉強をしています。初心者です。
サーバーに自分の作品をアップして、挙動チェックをしていたところ、
コンソールに

Synchronous XMLHttpRequest on the main thread is deprecated because of its detrimental effects to the end user's experience. For more help, check https://xhr.spec.whatwg.org/.

って警告がでました。

これって、XMLHttpRequestを使うなら非同期でお願いします。ってそのまんまの意味ですよね？

しかし、自分の作ったものにXMLHttpRequestは使っていなくて
何のことなのか何が悪いのか全くわかりません。

自分の PC でファイルを開くと出ないですし、
何が悪いのか突き止めるために１つずつ削っていきましたが
```ここに言語を入力
<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <p>テスト</p>
</body>
</html>
```

これだけになっても、まだ警告が出ます。

ここまでくると、javascript は関係ないのかもしれませんが
XMLHttpRequest って言葉が発端だったので
申し訳ないのですがここで質問させて頂きます。

どなたか、このことについて詳しい方いらっしゃいませんか？
よろしくお願いいたします。

---
追記

IE, edge, firefoxでは警告が出ません。

chrome で警告が出ます。シークレットウィンドウでは出ませんでした。

メインスレッドでの同期XMLHttpRequestは、エンドユーザーエクスペリエンスに悪影響を与えるため、非推奨です。

###前提・実現したいこと
JavaScriptで処理を順番に実行したいと考えています。

例えば以下のような処理があったとします。

###該当のソースコード
```javascript
heavy_function1();
heavy_function2();

other_function();
```

この関数heavy_function1()とheavy_function2()はものすごく重い処理です。
しかし、二つの関数heavy_function1()、heavy_function2()で取得したデータがを用いないとother_function()は正常に動作しません。
こういった場合、heavy_function1()、heavy_function2()が終了してからother_function()を実行するにはどのようにしたらよいのでしょうか？
ご回答をいただけると助かりますm(._.)m

###試したこと
http://www.hp-stylelink.com/news/2013/11/20131126.php
上記サイトを参考に試したのですが、setIntervalメソッドでは、if文を書かなければならず、私のやりたい処理の場合結構複雑になってしまいます。
そうではなく、単純に「heavy_function1()、heavy_function2()が終わってから」というふうにしたです。

JavaScriptで処理を順番に実行したい

UIとは別に非同期で無限ループするクラスの作成方法

お世話になっております。
WFPアプリケーションにて、サーバーから値を取得して、処理を行うクラスを作成したいと思っております。
基本的に、アプリが起動してから終了するまでの期間中動作させることを想定しております。

以下のようにしてしまうと、UI側は固まってしまうと思います
```csharp
Class Recv
{
    Recv()
    {
        Loop();
    }
    void Loop()
    {
        while(true)
        {
            int a = GetValue(); // サーバーから値をもらうと仮定
            a += 10;
            Console.WriteLine(a);
            Thread.Sleep(1000);
        }
    }
}

// UI側から
Recv r = new Recv();
```

**質問**
下記のような書き方を行えばUIが固まることはないのですが、問題ないでしょうか。
最適な方法がございましたら、よろしくお願いいたします。
```C#
Task.Run(() => Recv r = new Recv());
```

```C#
Recv()
{
    Task.Run(() => Loop());
}
```

UIとは別に非同期で無限ループするクラスの作成方法

### 助けてほしいこと
こんにちは。
今、C#の基本をやっています。
Form1クラスでタイマーをセットしているのですが、timer.Stop()でエラーになります。
これはどのようにすればよいか教えてほしいのです。

### 詳細

タイマーをセットしているところ
```C#
//タイマー
System.Timers.Timer timer;

private void Setimer(int time)
{
  // タイマーの生成
  timer = new System.Timers.Timer(time);
  timer.Elapsed +=  (sender, e) =>
  {
    test_async();
    timer.Stop();
    label_Timer.Text = "タイマーとめたよ";
　};

  timer.Start();
  label_Timer.Text = "タイマーはじめました";
}
```

タイマー時間経過で呼び出している関数
```C#
private async Task test_async()
{
	txtdata = textBox.Text;
	if (txtdata == "その１")
	{
		while (Test.Proc1(txtdata) == false)
		{
			//停止になってたらとめる
			if (Stopflg == true) break;
			//再読み込みまで100ms空ける
			await Task.Delay(100);
		}
		return;
	}

	//	非同期で動かす(固まっちゃうので)	
	await Task.Run(async () =>
	{
		while((Test.Proc2(txtdata) == false)
		{
			//停止になってたらとめる
			if (Stopflg == true) break;
			//100ms待ってから
			await Task.Delay(100);
		}
	});
	return;
}
```

### わからないこと
```C#
test_async();
```
がなければ、エラーになりませんので、ここが悪いとは思います。
```C#
await test_async();
```
にしてもだめでしたので、悩んでいます。
タイマーの呼び出しの中で非同期処理をしている関数を呼んではいけない、ということですか？

### 参考
参考にさせていただいたのはこちらの中ほどのコードでした。
https://webbibouroku.com/Blog/Article/cs-timer

### エラー
```
例外がスローされました: 'System.InvalidOperationException' (System.Windows.Forms.dll の中)
型 'System.InvalidOperationException' の例外が System.Windows.Forms.dll で発生しましたが、ユーザー コード内ではハンドルされませんでした
有効ではないスレッド間の操作: コントロールが作成されたスレッド以外のスレッドからコントロール 'label_Timer' がアクセスされました。
```

### 改めて
右も左もわからず、思うがまま組んでみてます。
そもそも、それじゃダメ、という意見もあるかと思います。
よろしければ、教えていただければうれしいです。

よろしくお願いいたします(*- -)(*_ _)ペコリ

タイマーの中で非同期処理はやっちゃだめですか？

### 前提・実現したいこと

以前も似たようなご質問をさせていただきましたが、再度質問させていただきます。
[以前の質問](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

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

JavaScriptでPromiseのthen()を繰り返す場合、途中で抜けるにはどうしたらいいのでしょうか。
return false;ではだめなようでした。
```JavaScript
FuncHoge()
.then(function(){
  console.log("1");
  return Promise; // ←ざっくり書いていますがPromiseオブジェクトをreturnしてます
})
.then(function () {
  console.log("2");
  if (hoge) {
    return false; // 次のthenに行ってほしくないがこれではだめ。console.log("3")が実行される
  } else {
    return Promise;
  }
})
.then(function () {
  console.log("3");
  return Promise;
})
.then(function () {
  console.log("4");
  return Promise;
});

```