🐩 🎸 👩‍🚒 赤いアーキテクチャ-複雑で複雑なシステムの赤いヘルプボタン-パート3（私たちを助けるマルチスレッド） 🏊 💬 🛒

Red Architectureの説明の最後の部分は、マルチスレッド専用です。公平を期すために、クラスvの初期バージョンは最適とは見なされません。現実世界のアプリケーションの開発者が避けられない主要な問題の1つを解決するものは何もないためです。現在の記事を完全に理解するには、ここでRed Architectureの概念を理解する必要があります。

赤い建築

今後は、クラスvの制限を超えることなく、マルチスレッドのすべての問題を解決できると言います。さらに、見た目よりもはるかに少ない変更が行われ、その結果、完全に解決されたマルチスレッドの問題を含むクラスvコードは、50行強で構成されます！さらに、最初のパートで説明したクラスvのバージョンよりも、わずかな50行が最適です。この場合、スレッド同期の問題を解決する特定のコードは20行しかかかりません！

テキストの過程で、この記事の最後にある完成したクラスvとテストのリストから個々の行を解析します。

Red Architectureはどこに適用できますか？

ここで紹介する例は、 Red Architectureの概念全体と同様に、 可能なすべての言語とプラットフォームで使用できるように提供されていることを強調したいと思います。 C＃/ Xamarinと.NETプラットフォームは、個人的な好みに基づいてRed Architectureをデモンストレーションするために選ばれました。

クラスvの2つのバリアント

クラスvの2つのバリアントがあります。機能と1番目の使用方法が同じ2番目のオプションは、やや複雑になります。しかし、「標準」のC＃.NET環境だけでなく、XamarinのPCL環境でも使用できます。つまり、3つのプラットフォーム（iOS、Android、Windows 10 Mobile）でのモバイル開発を意味します。実際、XamarinフレームワークのPCL環境ではスレッドセーフコレクションを使用できないため、Xamarin / PCLのクラスvのバージョンには、スレッドを同期するためのコードが多く含まれます。これは、この記事で検討することです。クラスvの簡易バージョン（この記事の最後にあります）は、マルチスレッドの問題とその解決方法を理解する上であまり価値がありません。

少しの最適化

まず、基本クラスを取り除き、クラスvを自給自足にします。今まで使用してきた基本クラスの通知メカニズムは必要ありません。継承されたメカニズムでは、マルチスレッドの問題を最適な方法で解決することはできません。したがって、次はハンドラー関数にイベントを送信します。

static Dictionary<k, HashSet<NotifyCollectionChangedEventHandler>> handlersMap = new Dictionary<k, HashSet<NotifyCollectionChangedEventHandler>>(); // ... foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key])) lock(handlr) try { handlr.Invoke(key, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<KeyValuePair<k, object>>(){ new KeyValuePair<k, object>(key, o) }));

foreachループのAdd（）メソッドで、要素をHashSet 'aからListにコピーし、ハッシュセットではなくシートを反復処理します。 handlersMap [key]式によって返される値は、m（）やh（）などのパブリック状態変更メソッドからアクセス可能なグローバル変数であるため、これを行う必要があります。したがって、handlersMap [key]式によって返されるHashMapはAdd（）メソッドでの反復中に別のスレッドによって変更されます。foreach内のコレクションの反復が完了するまで、その（コレクション）変更は禁止されているため、実行時に実行されます。これが、グローバル変数ではなく、グローバルHashSetの要素がコピーされるListを反復で「置換」する理由です。

しかし、この保護は十分ではありません。式で

 new List<NotifyCollectionChangedEventHandler>(handlersMap[key])

コピー操作は、handlersMap [key]の値（ハッシュセット）に暗黙的に適用されます。コピー操作の開始と終了の間に、他のスレッドがコピーされたハッシュセットの要素を追加または削除しようとすると、これは間違いなく問題を引き起こします。したがって、foreachの開始直前にこのハッシュにロック（Monitor.Enter（handlersMap [key]））を設定します。

 Monitor.Enter(handlersMap[key]); foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key])) { // ...

「リリース」（Monitor.Exit（handlersMap [キー]））foreachループに入った直後にロックする

 foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key])) { if (Monitor.IsEntered(handlersMap[key])) { Monitor.PulseAll(handlersMap[key]); Monitor.Exit(handlersMap[key]); } // ...

Monitorオブジェクトのルールに従って、Enter（）の呼び出しの数はExit（）の呼び出しの数に対応する必要があるため、ロックがインストールされた場合に1つだけが終了することを確認するifチェック（Monitor.IsEntered（handlersMap [key]））があります回、foreachループの最初の反復の開始時。行Monitor.Exit（handlersMap [key]）の直後に、haslers handlersMap [key]が他のスレッドで再び使用可能になります。したがって、ハッシュロックを可能な最小時間に制限します。この場合、ハッシュは文字通り一時的にブロックされると言えます。

foreachループの直後に、ロック解除コードの繰り返しが表示されます。

 // ... if (Monitor.IsEntered(handlersMap[key])) { Monitor.PulseAll(handlersMap[key]); Monitor.Exit(handlersMap[key]); } // ...

このコードは、foreachに反復がない場合に必要です。これは、キーの1つに対して、対応するハッシュセットに単一のハンドラーがない場合に可能です。

次のコードには詳細な説明が必要です。

  lock(handlr) try { // ...

実際、Red Architectureの概念では、クラスvの外部で作成され、スレッドの同期を必要とするオブジェクトはハンドラー関数のみです。ハンドラーが関数を呼び出すコードを管理できなかった場合、各ハンドラーのように「フェンス」する必要があります

 void OnEvent(object sender, NotifyCollectionChangedEventArgs e) { lock(OnEvent); //    unlock(OnEvent); }

lock（）unlock（）行の間に有用なメソッドコードが配置されていることに注意してください。外部のハンドラー内のデータが変更された場合、lock（）およびunlock（）を追加する必要があります。同時に、この関数に入るフローは、混variablesとした順序で外部変数の値を変更するためです。

しかし、代わりに、プログラム全体に1行（ロック（handlr））を追加し、vクラス内でこれを外部の何も触れずに行いました！ vクラスの実装により、1つのスレッドのみがこの特定のハンドラーに入ることが保証され、他のスレッドはロック（「ハンドラー」）に「立ち」、この作業が完了するまで待機するため、スレッドの安全性を考えずに任意の数のハンドラー関数を作成できますそれを入力した前のスレッドのハンドラー。

foreach、for（;;）およびマルチスレッド

テストのリスト（記事の最後）には、2つのスレッドがこのメソッドに入り、したがってfor（;;）ループに入るときにfor（;;）ループの動作をチェックするforeachTest（string [] a）メソッドがあります。以下は、このメソッドの出力の可能な部分です。

// ...

〜：string20

〜：string21

〜：string22

〜：astring38

〜：astring39

〜：string23

〜：string24

〜：astring40

〜：astring41

〜：string25

〜：astring42

〜：string26

〜：astring43

〜：astring44

〜：string27

〜：astring45

〜：string28

// ...

「string」行と「astring」行の出力が混在しているにもかかわらず、各行の数値の接尾辞は順番に並んでいます。各行を出力するために、ローカル変数iが真になります。この結論は、for（;;）への2つのスレッドの同時入力が安全であることを示唆しています。おそらく、for（;;）構造のフレームワークで宣言されたすべての変数、たとえば変数int iは、for（;;）に入ったストリームのスタック上に作成されます。そのため、（;;）の内部で作成された変数へのアクセスは、「手動」同期を必要としません。なぜなら、それらは、スタックが作成されたスレッドでのみ利用可能だからです。これは、C＃と.NETプラットフォームの場合です。他の言語では、可能性は低いですが、異なる動作がある可能性があるため、このようなテストは不要ではありません。

try ... catchは例外ではなく標準です

try ... catch一見、この構造は不要に思えますが、重要です。 handlr.Invoke（）の呼び出し時に、handlrが定義されたオブジェクトが破壊された状況から私たちを保護することを目的としています。オブジェクトの破棄は、行間でいつでも別のスレッドまたはガベージコレクターによって実行できます。

 foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key]))

そして

 handlr.Invoke();

catchブロックである例外処理では、ハンドラーがnull（削除済み）オブジェクトを参照しているかどうかを確認し、ハンドラーリストから単純に削除します。

 lock (handlr) try { handlr.Invoke(key, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<KeyValuePair<k, object>>(){ new KeyValuePair<k, object>(key, o) })); #if __tests__ /* check modification of global collection of handlers for a key while iteration through its copy */ handlersMap[key].Add((object sender, NotifyCollectionChangedEventArgs e) => { }); #endif } catch (Exception e) { // because exception can be thrown inside handlr.Invoke(), but before handler was destroyied. if (ReferenceEquals(null,handlr) && e is NullReferenceException) // handler invalid, remove it m(handlr); else // exception in handler's body throw e; }

クラスvの初期化

静的コンストラクターは、C＃の特徴の1つです。直接呼び出すことはできません。このクラスの最初のオブジェクトを作成する前に、一度だけ自動的に呼び出されます。これを使用してhandlersMapを初期化します-kのすべてのキーに対して、各キーのハンドラー関数を格納するための空のHashSetを使用する準備をします。他の言語に静的コンストラクターがない場合、オブジェクトを初期化するメソッドが適しています。

 static v() { foreach (ke in Enum.GetValues(typeof(k))) handlersMap[e] = new HashSet<NotifyCollectionChangedEventHandler>(); new Tests().run(); }

スレッドの安全でないコレクションをどうするか？

C＃クラスのHashSetは、複数のスレッド（スレッドセーフではない）からの変更時に同期を提供しないため、このオブジェクトの変更、つまり要素の削除と追加を同期する必要があります。この場合、クラスvのメソッドm（）、h（）で要素を削除/追加する操作の直前に、1つの行ロック（handlersMap [key]）を追加するだけで十分です。この場合、フローをブロックするオブジェクトは、この特定のキーに関連付けられたHashMapオブジェクトになります。これにより、1つのスレッドのみでこの特定のハッシュセットを変更できます。

マルチスレッドの副作用

マルチスレッドの「副作用」のいくつかに言及する価値があります。特に、ハンドラー関数のコードは、場合によってはハンドラー関数の「サブスクライブ解除」後にイベントを受信した後に呼び出されるという事実に備えて準備する必要があります。つまり、m（キー、ハンドラー）ハンドラーをしばらく（おそらく1秒未満）呼び出した後でも呼び出すことができます。これは、m（）メソッドでhandlersMap [key] .Remove（handler）を呼び出したときに、このハンドラーがforeach行の別のスレッドによって既にコピーされている可能性があるためです（新しいリストのvar handlr（handlersMap [key]））、およびm（）メソッドで削除された後、クラスvのAdd（）メソッドで呼び出されます。

複雑な問題を解決する簡単なルール

結論として、私は勤勉な開発者であるため、ロックの使用に関する合意に違反しないという事実に注意を喚起したいと思います。特に、このような契約は、このページのdocs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/lock-statementの備考セクションにリストされています。 C＃だけでなく、すべての言語に共通です。これらの契約の本質は次のとおりです。

パブリック型をロックのオブジェクトとして使用しないでください。

ロックには2種類のオブジェクトを使用し、両方ともプライベートです。最初のタイプは、クラスvにプライベートなHashSetオブジェクトです。 2番目の型は、関数ハンドラー型のオブジェクトです。関数ハンドラは、それらを宣言し、それらを使用してイベントを受信するすべてのオブジェクトでプライベートとして宣言されます。 Red Architectureの場合、vクラスのみがハンドラーを直接呼び出す必要があり、それ以外は何も呼び出しません。

以下は、vクラスとTestsクラスの完成したコードです。 C＃では、ここからコピーして直接使用できます。このコードを他の言語に翻訳することは、あなたにとって小さな楽しい仕事になります。

以下は、「ユニバーサル」クラスvのコードです。これは、Xamarin / C＃プラットフォームに基づくモバイルアプリケーションプロジェクトでも使用できます。

 using System; using System.Collections.Generic; using System.Collections.Specialized; using System.Threading; namespace Common { public enum k {OnMessageEdit, MessageEdit, MessageReply, Unused, MessageSendProgress, OnMessageSendProgress, OnIsTyping, IsTyping, MessageSend, JoinRoom, OnMessageReceived, OnlineStatus, OnUpdateUserOnlineStatus } public class v { static Dictionary<k, HashSet<NotifyCollectionChangedEventHandler>> handlersMap = new Dictionary<k, HashSet<NotifyCollectionChangedEventHandler>>(); public static void h(k[] keys, NotifyCollectionChangedEventHandler handler) { foreach (var key in keys) lock(handlersMap[key]) handlersMap[key].Add(handler); } public static void m(NotifyCollectionChangedEventHandler handler) { foreach (k key in Enum.GetValues(typeof(k))) lock(handlersMap[key]) handlersMap[key].Remove(handler); } public static void Add(k key, object o) { Monitor.Enter(handlersMap[key]); foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key])) { if (Monitor.IsEntered(handlersMap[key])) { Monitor.PulseAll(handlersMap[key]); Monitor.Exit(handlersMap[key]); } lock (handlr) try { handlr.Invoke(key, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<KeyValuePair<k, object>>(){ new KeyValuePair<k, object>(key, o) })); #if __tests__ /* check modification of global collection of handlers for a key while iteration through its copy */ handlersMap[key].Add((object sender, NotifyCollectionChangedEventArgs e) => { }); #endif } catch (Exception e) { // because exception can be thrown inside handlr.Invoke(), but before handler was destroyied. if (ReferenceEquals(null,handlr) && e is NullReferenceException) // handler invalid, remove it m(handlr); else // exception in handler's body throw e; } } if (Monitor.IsEntered(handlersMap[key])) { Monitor.PulseAll(handlersMap[key]); Monitor.Exit(handlersMap[key]); } } static v() { foreach (ke in Enum.GetValues(typeof(k))) handlersMap[e] = new HashSet<NotifyCollectionChangedEventHandler>(); new Tests().run(); } } }

以下は、「標準」C＃.NETプラットフォームで使用できる「単純化された」クラスvのコードです。「ユニバーサル」カウンターパートとの唯一の違いは、HashMapの代わりにConcurrentBagコレクションを使用していることです。HashMapは、自分にアクセスするときにすぐに使用できるフローの同期を提供するタイプです。 HashSetの代わりにConcurrentBagを使用すると、スレッドを同期するコードのほとんどをクラスvから削除できます。

 using System; using System.Collections.Generic; using System.Collections.Specialized; using System.Collections.Concurrent; using System.Threading; namespace Common { public enum k { OnMessageEdit, MessageEdit, MessageReply, Unused, MessageSendProgress, OnMessageSendProgress, OnIsTyping, IsTyping, MessageSend, JoinRoom, OnMessageReceived, OnlineStatus, OnUpdateUserOnlineStatus } public class v { static Dictionary<k, ConcurrentBag<NotifyCollectionChangedEventHandler>> handlersMap = new Dictionary<k, ConcurrentBag<NotifyCollectionChangedEventHandler>>(); public static void h(k[] keys, NotifyCollectionChangedEventHandler handler) { foreach (var key in keys) handlersMap[key].Add(handler); } public static void m(NotifyCollectionChangedEventHandler handler) { foreach (k key in Enum.GetValues(typeof(k))) handlersMap[key].Remove(handler); } public static void Add(k key, object o) { foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key])) { lock (handlr) try { handlr.Invoke(key, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<KeyValuePair<k, object>>(){ new KeyValuePair<k, object>(key, o) })); #if __tests__ /* check modification of global collection of handlers for a key while iteration through its copy */ handlersMap[key].Add((object sender, NotifyCollectionChangedEventArgs e) => { }); #endif } catch (Exception e) { // because exception can be thrown inside handlr.Invoke(), but before handler was destroyied. if (ReferenceEquals(null,handlr) && e is NullReferenceException) // handler invalid, remove it m(handlr); else // exception in handler's body throw e; } } } static v() { foreach (ke in Enum.GetValues(typeof(k))) handlersMap[e] = new ConcurrentBag<NotifyCollectionChangedEventHandler>(); new Tests().run(); } } }

以下に、Testsクラスのコードを示します。このクラスは、vのマルチスレッド使用とハンドラー関数をテストします。コメントに注意してください。彼らはテストとテストコードがどのように機能するかについて多くの有用な情報を持っています。

 using System; using System.Collections.Generic; using System.Collections.Specialized; using System.Threading.Tasks; using System.Diagnostics; using System.Linq; namespace ChatClient.Core.Common { class DeadObject { void OnEvent(object sender, NotifyCollectionChangedEventArgs e) { var newItem = (KeyValuePair<k, object>)e.NewItems[0]; Debug.WriteLine(String.Format("~ OnEvent() of dead object: key: {0} value: {1}", newItem.Key.ToString(), newItem.Value)); } public DeadObject() { vh(new k[] { k.OnlineStatus }, OnEvent); } ~DeadObject() { // Accidentally we forgot to call vm(OnEvent) here, and now v.handlersMap contains reference to "dead" handler } } public class Tests { void OnEvent(object sender, NotifyCollectionChangedEventArgs e) { var newItem = (KeyValuePair<k, object>)e.NewItems[0]; Debug.WriteLine(String.Format("~ OnEvent(): key: {0} value: {1}", newItem.Key.ToString(), newItem.Value)); if (newItem.Key == k.Unused) { // v.Add(k.Unused, "stack overflow crash"); // reentrant call in current thread causes stack overflow crash. Deadlock doesn't happen, because lock mechanism allows reentrancy for a thread that already has a lock on a particular object // Task.Run(() => v.Add(k.Unused, "deadlock")); // the same call in a separate thread don't overflow, but causes infinite recursive loop } } void OnEvent2(object sender, NotifyCollectionChangedEventArgs e) { var newItem = (KeyValuePair<k, object>)e.NewItems[0]; Debug.WriteLine(String.Format("~ OnEvent2(): key: {0} value: {1}", newItem.Key.ToString(), newItem.Value)); } void foreachTest(string[] a) { for (int i = 0; i < a.Length; i++) { Debug.WriteLine(String.Format("~ : {0}{1}", a[i], i)); } } async void HandlersLockTester1(object sender, NotifyCollectionChangedEventArgs e) { var newItem = (KeyValuePair<k, object>)e.NewItems[0]; Debug.WriteLine(String.Format("~ HandlersLockTester1(): key: {0} value: {1}", newItem.Key.ToString(), newItem.Value)); await Task.Delay(300); } async void HandlersLockTester2(object sender, NotifyCollectionChangedEventArgs e) { var newItem = (KeyValuePair<k, object>)e.NewItems[0]; Debug.WriteLine(String.Format("~ HandlersLockTester2(): key: {0} value: {1}", newItem.Key.ToString(), newItem.Value)); } public async void run() { // Direct call for garbage collector - should be called for testing purposes only, not recommended for a business logic of an application GC.Collect(); /* * == test v.Add()::foreach (var handlr in new List<NotifyCollectionChangedEventHandler>(handlersMap[key])) * for two threads entering the foreach loop at the same time and iterating handlers only of its key */ Task t1 = Task.Run(() => { v.Add(k.OnMessageReceived, "this key"); }); Task t2 = Task.Run(() => { v.Add(k.MessageEdit, "that key"); }); // wait for both threads to complete before executing next test await Task.WhenAll(new Task[] { t1, t2 }); /* For now DeadObject may be already destroyed, so we may test catch block in v class */ v.Add(k.OnlineStatus, "for dead object"); /* test reentrant calls - causes stack overflow or infinite loop, depending on code at OnEvent::if(newItem.Key == k.Unused) clause */ v.Add(k.Unused, 'a'); /* testing foreach loop entering multiple threads */ var s = Enumerable.Repeat("string", 200).ToArray(); var n = Enumerable.Repeat("astring", 200).ToArray(); t1 = Task.Run(() => { foreachTest(s); }); t2 = Task.Run(() => { foreachTest(n); }); // wait for both threads to complete before executing next test await Task.WhenAll(new Task[] { t1, t2 }); /* testing lock(handlr) in Add() method of class v */ vh(new k[] { k.IsTyping }, HandlersLockTester1); vh(new k[] { k.JoinRoom }, HandlersLockTester2); // line 1 Task.Run(() => { v.Add(k.IsTyping, "first thread for the same handler"); }); // line 2 Task.Run(() => { v.Add(k.IsTyping, "second thread for the same handler"); }); // line below will MOST OF THE TIMES complete executing before the line 2 above, because line 2 will wait completion of line 1 // since both previous lines 1 and 2 are calling the same handler, access to which is synchronized by lock(handlr) in Add() method of class v Task.Run(() => { v.Add(k.JoinRoom, "third thread for other handler"); }); } public Tests() { // add OnEvent for each key vh(new k[] { k.OnMessageReceived, k.MessageEdit, k.Unused }, OnEvent); // add OnEvent2 for each key vh(new k[] { k.Unused, k.OnMessageReceived, k.MessageEdit }, OnEvent2); /* == test try catch blocks in v class, when handler is destroyed before handlr.Invoke() called */ var ddo = new DeadObject(); // then try to delete object, setting its value to null. We are in a managed environment, so we can't directly manage life cicle of an object. ddo = null; } } }

ハンドラー関数を登録するコードと、そのようなクラスvのハンドラー関数自体は、次のようになります。

ハンドラー機能登録コード

 // add OnEvent for each key vh(new k[] { k.OnMessageReceived, k.MessageEdit, k.Unused }, OnEvent);

ハンドラー機能コード

 void OnEvent(object sender, NotifyCollectionChangedEventArgs e) { var newItem = (KeyValuePair<k, object>)e.NewItems[0]; Debug.Write("~ OnEvent(): key {0} value {1}", newItem.Key.ToString(), newItem.Value); }

Red Architectureの一般的な説明はこちらです。

赤いアーキテクチャ-複雑で複雑なシステムの赤いヘルプボタン-パート3（私たちを助けるマルチスレッド）