Refactoring of Multithreading samples, added GarbageCollection sample and Thread sample

Author: ahotko

CSharp Code Samples/CodeSamples/CodeSamples.csproj

@@ -65,6 +65,8 @@
     <Compile Include="Constants.cs" />
     <Compile Include="ISampleExecute.cs" />
     <Compile Include="MultiThreading\BackgroundWorkerSample.cs" />
+    <Compile Include="MultiThreading\MultithreadingSample.cs" />
+    <Compile Include="MultiThreading\ThreadSample.cs" />
     <Compile Include="Patterns\Behavioral\ObserverPattern.cs" />
     <Compile Include="Patterns\Behavioral\StatePattern.cs" />
     <Compile Include="Patterns\Creational\AbstractFactoryPattern.cs" />
@@ -97,6 +99,7 @@
     <Compile Include="TupleDeconstruction\TupleDeconstruction.cs" />
     <Compile Include="UsefulClasses\Dictionaries.cs" />
     <Compile Include="UsefulClasses\ObjectPoolSample.cs" />
+    <Compile Include="Useful\GarbageCollectionSample.cs" />
     <Compile Include="Useful\LinqSample.cs" />
     <Compile Include="Classes\ClassAndMethodNamesSample.cs" />
   </ItemGroup>

CSharp Code Samples/CodeSamples/MultiThreading/BackgroundWorkerSample.cs

@@ -4,15 +4,12 @@
 
 namespace CodeSamples.MultiThreading
 {
-    public class BackgroundWorkerSample : SampleExecute
+    public class BackgroundWorkerSample
     {
         private readonly AutoResetEvent resetEvent = new AutoResetEvent(false);
 
-        public override void Execute()
+        public void Go()
         {
-            Title("BackgroundWorkerSampleExecute");
-            Section("BackgroundWorker is...");
-
             BackgroundWorker backgroundWorker = new BackgroundWorker();
             backgroundWorker.DoWork += new DoWorkEventHandler(BackgroundWorker_DoWork);
             backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorker_RunWorkerCompleted);
@@ -26,7 +23,6 @@ public override void Execute()
             }
             //wait for background worker to finish; not necessary, but required for testing samples, so they execute in order
             resetEvent.WaitOne();
-            Finish();
         }
 
         private void BackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)

CSharp Code Samples/CodeSamples/MultiThreading/MultithreadingSample.cs

@@ -0,0 +1,22 @@
+namespace CodeSamples.MultiThreading
+{
+    public class MultithreadingSample : SampleExecute
+    {
+        public override void Execute()
+        {
+            Title("MultithreadingSample");
+
+            Section("BackgroundWorker is online...");
+            var backgroundWorkerSample = new BackgroundWorkerSample();
+            backgroundWorkerSample.Go();
+
+            LineBreak();
+
+            Section("Thread is online...");
+            var threadSample = new ThreadSample();
+            threadSample.Go();
+
+            Finish();
+        }
+    }
+}

CSharp Code Samples/CodeSamples/MultiThreading/ThreadSample.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Threading;
+
+namespace CodeSamples.MultiThreading
+{
+    internal class LaborInstructions
+    {
+        private readonly AutoResetEvent _syncObject;
+
+        public string SomeParameter { get; set; }
+
+        public AutoResetEvent SyncObject => _syncObject;
+
+        public LaborInstructions(AutoResetEvent syncObject)
+        {
+            _syncObject = syncObject;
+        }
+    }
+
+    internal class ThreadLabor
+    {
+        public void DoWork(object instructions)
+        {
+            var passedParametersClass = instructions as LaborInstructions;
+            Console.WriteLine($"Doing labor... {passedParametersClass.SomeParameter} ... and waiting to complete...");
+            Thread.Sleep(1000);
+            passedParametersClass.SyncObject.Set();
+        }
+    }
+
+    public class ThreadSample
+    {
+        private readonly AutoResetEvent syncObject = new AutoResetEvent(false);
+
+        public void Go()
+        {
+            var threadLabor = new ThreadLabor();
+            var laborInstructions = new LaborInstructions(syncObject);
+            laborInstructions.SomeParameter = $"Current DateTime is {DateTime.Now.ToString()}";
+
+            Console.WriteLine("Going into thread...");
+            var thread = new Thread(threadLabor.DoWork);
+            thread.Priority = ThreadPriority.Highest;
+            thread.Start(laborInstructions);
+            syncObject.WaitOne();
+            Console.WriteLine("done!");
+        }
+    }
+}

CSharp Code Samples/CodeSamples/Program.cs

@@ -108,8 +108,8 @@ static void Main(string[] args)
             #endregion
 
             #region Threading
-            var backgroundWorkerSample = new BackgroundWorkerSample();
-            backgroundWorkerSample.Execute();
+            var multithreadingSample = new MultithreadingSample();
+            multithreadingSample.Execute();
             #endregion
 
             #region Equality
@@ -130,6 +130,11 @@ static void Main(string[] args)
             timingSample.Execute();
             #endregion
 
+            #region Garbage Collection
+            var gcSample = new GarbageCollectionSample();
+            gcSample.Execute();
+            #endregion
+
             Console.WriteLine();
             Console.WriteLine("End Code Samples");
 

CSharp Code Samples/CodeSamples/Useful/GarbageCollectionSample.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Threading;
+
+/// <summary>
+/// System.Runtime.GCLatencyMode.SustainedLowLatency
+/// https://docs.microsoft.com/en-us/dotnet/api/system.runtime.gclatencymode?view=netcore-3.1
+/// 
+/// Batch                 Disables garbage collection concurrency and reclaims
+///                       objects in a batch call. This is the most intrusive mode.
+/// 					  This mode is designed for maximum throughput at the
+/// 					  expense of responsiveness.
+/// 
+/// Interactive           Enables garbage collection concurrency and reclaims
+///                       objects while the application is running. This is
+/// 					  the default mode for garbage collection on a
+/// 					  workstation and is less intrusive than Batch.
+/// 					  It balances responsiveness with throughput. This
+/// 					  mode is equivalent to garbage collection on a
+/// 					  workstation that is concurrent.
+/// 
+/// LowLatency            Enables garbage collection that is more conservative
+///                       in reclaiming objects. Full collections occur only
+/// 					  if the system is under memory pressure, whereas
+/// 					  generation 0 and generation 1 collections might occur
+/// 					  more frequently. This mode is not available for the
+/// 					  server garbage collector.
+/// 
+/// NoGCRegion            Indicates that garbage collection is suspended while 
+///                       the app is executing a critical path.
+///                       NoGCRegion is a read-only value; that is, you cannot
+/// 					  assign the NoGCRegion value to the LatencyMode property.
+/// 					  You specify the no GC region latency mode by calling the
+/// 					  TryStartNoGCRegion method and terminate it by calling the
+/// 					  EndNoGCRegion() method.
+/// 
+/// SustainedLowLatency   Enables garbage collection that tries to minimize latency
+///                       over an extended period. The collector tries to perform
+/// 					  only generation 0, generation 1, and concurrent
+/// 					  generation 2 collections. Full blocking collections may 
+/// 					  still occur if the system is under memory pressure.
+/// </summary>
+
+namespace CodeSamples.Useful
+{
+    public class GarbageCollectionSample : SampleExecute
+    {
+        private void TurnGarbageCollectionOff()
+        {
+            Console.Write("Turning Garbage Collection into low latency (= off)...");
+            System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.SustainedLowLatency;
+            Console.WriteLine("done!");
+        }
+
+        private void TurnGarbageCollectionOn()
+        {
+            Console.Write("Turning Garbage Collection into interactive (= on)...");
+            System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.Interactive;
+            Console.WriteLine("done!");
+        }
+
+        public override void Execute()
+        {
+            Title("GarbageCollectionSample");
+            TurnGarbageCollectionOff();
+            Thread.Sleep(1000);
+            TurnGarbageCollectionOn();
+
+            Finish();
+        }
+    }
+}