Update scheduling-threads.md added an example code (#40739)

* Update scheduling-threads.md added an example code

Added an example code with description.

* Update docs/standard/threading/scheduling-threads.md

Co-authored-by: Bill Wagner <[email protected]>

* Update code snippet scheduling-threads.md

Before moving the code to a separate file.

* Code snippet moved to a sepparate file (project)

* Path fix

* typo fix

* Removed blank spaces

* Fixed typo and rephrased couple of sentences.

* Build fix

---------

Co-authored-by: Bill Wagner <[email protected]>

Author: victoravt

docs/standard/threading/scheduling-threads.md

@@ -11,8 +11,16 @@ ms.assetid: 67e4a0eb-3095-4ea7-b20f-908faa476277
 
 Every thread has a thread priority assigned to it. Threads created within the common language runtime are initially assigned the priority of <xref:System.Threading.ThreadPriority.Normal?displayProperty=nameWithType>. Threads created outside the runtime retain the priority they had before they entered the managed environment. You can get or set the priority of any thread with the <xref:System.Threading.Thread.Priority?displayProperty=nameWithType> property.  
 
- Threads are scheduled for execution based on their priority. Even though threads are executing within the runtime, all threads are assigned processor time slices by the operating system. The details of the scheduling algorithm used to determine the order in which threads are executed varies with each operating system. Under some operating systems, the thread with the highest priority (of those threads that can be executed) is always scheduled to run first. If multiple threads with the same priority are all available, the scheduler cycles through the threads at that priority, giving each thread a fixed time slice in which to execute. As long as a thread with a higher priority is available to run, lower priority threads do not get to execute. When there are no more runnable threads at a given priority, the scheduler moves to the next lower priority and schedules the threads at that priority for execution. If a higher priority thread becomes runnable, the lower priority thread is preempted and the higher priority thread is allowed to execute once again. On top of all that, the operating system can also adjust thread priorities dynamically as an application's user interface is moved between foreground and background. Other operating systems might choose to use a different scheduling algorithm.  
-  
+ Threads are scheduled for execution based on their priority. Even though threads are executing within the runtime, all threads are assigned processor time slices by the operating system. The details of the scheduling algorithm used to determine the order in which threads are executed vary with each operating system. Under some operating systems, the thread with the highest priority (of those threads that can be executed) is always scheduled to run first. If multiple threads with the same priority are all available, the scheduler cycles through the threads at that priority, giving each thread a fixed time slice in which to execute. As long as a thread with a higher priority is available to run, lower priority threads do not get to execute. When there are no more runnable threads at a given priority, the scheduler moves to the next lower priority and schedules the threads at that priority for execution. If a higher priority thread becomes runnable, the lower priority thread is preempted and the higher priority thread is allowed to execute once again. On top of all that, the operating system can also adjust thread priorities dynamically as an application's user interface is moved between foreground and background. Other operating systems might choose to use a different scheduling algorithm.  
+
+## Example
+
+Here is an example of the execution of 9 threads across all 5 priority levels from the <xref:System.Threading.Thread.Priority?displayProperty=nameWithType> enumeration where the last 5 are on highest priority level. Also, we have callback support from the previous article that in this context demonstrates that the order of thread initialization and prioritization may not always be reflected in subsequent code nor process executions start order. Meaning, we see here the parallel nature of code execution and demonstration of assigned processor time slices by the operating system for every thread. This highlights the influence and control of the environment in which threads are running. With that said, we certainly see that the highest priority threads are indeed receive priority in execution.
+
+The following code will produce arbitrary results on each execution. However, common sequence patterns of priorities being run could be observed after running the code multiple times and analyzing the outputs.
+
+:::code language="csharp" source="snippets/scheduling-threads/SchedulingThreads.cs":::
+
 ## See also
 
 - [Using Threads and Threading](using-threads-and-threading.md)

docs/standard/threading/snippets/scheduling-threads/SchedulingThreads.cs

@@ -0,0 +1,80 @@
+namespace snippets;
+
+public class SchedulingThreads
+{
+    public void RunMultipleThreadsOnDifferentPriorities()
+    {
+        var threadsList = new List<Thread>(9);
+
+        // Initialize 9 threads. 5 with Highest priority, and the first 4 from Lowest to Normal range.
+        for (int i = 0; i < 9; i++)
+        {
+            var thread = new Thread(() => { new ThreadWithCallback(Callback).Process(); });
+
+            if (i > 3)
+                thread.Priority = ThreadPriority.Highest;
+            else
+                thread.Priority = (ThreadPriority)i;
+
+            threadsList.Add(thread);
+        }
+
+        threadsList.ForEach(thread => thread.Start());
+    }
+
+    public void Callback(ThreadPriority threadPriority)
+    {
+        Console.WriteLine($"Callback in {threadPriority} priority. \t\t ThreadId: {Thread.CurrentThread.ManagedThreadId}.");
+    }
+
+    public class ThreadWithCallback
+    {
+        public ThreadWithCallback(Action<ThreadPriority> callback)
+        {
+            this.callback = callback;
+        }
+
+        public Action<ThreadPriority> callback;
+
+        public void Process()
+        {
+            Console.WriteLine($"Entered process in {Thread.CurrentThread.Priority} priority.  \t\t ThreadId: {Thread.CurrentThread.ManagedThreadId}.");
+            Thread.Sleep(1000);
+            Console.WriteLine($"Finished process in {Thread.CurrentThread.Priority} priority. \t\t ThreadId: {Thread.CurrentThread.ManagedThreadId}.");
+
+            if (callback != null)
+            {
+                callback(Thread.CurrentThread.Priority);
+            }
+        }
+    }
+
+    // The example displays the output like the following:
+    //      Entered process in Highest priority.             ThreadId: 9.
+    //      Entered process in Highest priority.             ThreadId: 12.
+    //      Entered process in Normal priority.              ThreadId: 6.
+    //      Entered process in BelowNormal priority.         ThreadId: 5.
+    //      Entered process in Lowest priority.              ThreadId: 4.
+    //      Entered process in AboveNormal priority.         ThreadId: 7.
+    //      Entered process in Highest priority.             ThreadId: 11.
+    //      Entered process in Highest priority.             ThreadId: 10.
+    //      Entered process in Highest priority.             ThreadId: 8.
+    //      Finished process in Highest priority.            ThreadId: 9.
+    //      Finished process in Highest priority.            ThreadId: 12.
+    //      Finished process in Highest priority.            ThreadId: 8.
+    //      Finished process in Highest priority.            ThreadId: 10.
+    //      Callback in Highest priority.                    ThreadId: 10.
+    //      Finished process in AboveNormal priority.        ThreadId: 7.
+    //      Callback in AboveNormal priority.                ThreadId: 7.
+    //      Finished process in Lowest priority.             ThreadId: 4.
+    //      Callback in Lowest priority.                     ThreadId: 4.
+    //      Finished process in Normal priority.             ThreadId: 6.
+    //      Callback in Highest priority.                    ThreadId: 9.
+    //      Callback in Highest priority.                    ThreadId: 8.
+    //      Callback in Highest priority.                    ThreadId: 12.
+    //      Finished process in Highest priority.            ThreadId: 11.
+    //      Callback in Highest priority.                    ThreadId: 11.
+    //      Callback in Normal priority.                     ThreadId: 6.
+    //      Finished process in BelowNormal priority.        ThreadId: 5.
+    //      Callback in BelowNormal priority.                ThreadId: 5.
+}

docs/standard/threading/snippets/scheduling-threads/ThreadSnippets.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>