main

Author: sharpchen

…/Synchronization/Problem of Atomicity.md …ynchronization/1.Problem of Atomicity.mddocs/document/Modern CSharp/docs/Parallel Programming/Synchronization/Problem of Atomicity.md renamed to docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/1.Problem of Atomicity.md docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/Problem of Atomicity.md renamed to docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/1.Problem of Atomicity.md

@@ -35,46 +35,35 @@ BankAccount account = new();
 
 Mutex mutex = new(); // use one mutex for only one object
 
-var deposits = Enumerable.Range(1, 1000).Select(_ => Task.Run(() =>
-{
+var deposits = Enumerable.Range(1, 1000).Select(_ => Task.Run(() => {
     bool locked = mutex.WaitOne();
-    try
-    {
+    try {
         if (locked) account.Deposit(100);
-    }
-    finally
-    {
+    } finally {
         if (locked) mutex.ReleaseMutex();
     }
 }));
-var withdraws = Enumerable.Range(1, 1000).Select(_ => Task.Run(() =>
-{
+var withdraws = Enumerable.Range(1, 1000).Select(_ => Task.Run(() => {
     bool locked = mutex.WaitOne();
-    try
-    {
+    try {
         if (locked) account.Withdraw(100);
-    }
-    finally
-    {
+    } finally {
         if (locked) mutex.ReleaseMutex();
     }
 }));
 ```
 
 ```cs[Like Monitor]
-public class BankAccount
-{
+public class BankAccount {
     public int Balance { get; private set; }
     // this is not recommeneded // [!code warning] 
     private readonly Mutex _mutex = new(); // [!code ++] 
-    public void Deposit(int amount)
-    {
+    public void Deposit(int amount) {
         _mutex.WaitOne(); // [!code ++] 
         Balance += amount;
         _mutex.ReleaseMutex(); // [!code ++] 
     }
-    public void Withdraw(int amount)
-    {
+    public void Withdraw(int amount) {
         _mutex.WaitOne(); // [!code ++] 
         Balance -= amount;
         _mutex.ReleaseMutex(); // [!code ++]
@@ -105,44 +94,31 @@ BankAccount to = new();
 Mutex mutexFrom = new(); // [!code highlight] 
 Mutex mutexTo = new(); // [!code highlight] 
 
-var deposits = Enumerable.Range(1, 1000).Select(_ => Task.Run(() =>
-{
+var deposits = Enumerable.Range(1, 1000).Select(_ => Task.Run(() => {
     bool locked = mutexFrom.WaitOne();
-    try
-    {
+    try {
         if (locked) from.Deposit(100);
-    }
-    finally
-    {
+    } finally {
         if (locked) mutexFrom.ReleaseMutex();
     }
 }));
 
-var withdraws = Enumerable.Range(1, 1000).Select(_ => Task.Run(() =>
-{
+var withdraws = Enumerable.Range(1, 1000).Select(_ => Task.Run(() => {
     bool locked = mutexTo.WaitOne();
-    try
-    {
+    try {
         if (locked) to.Withdraw(100);
-    }
-    finally
-    {
+    } finally {
         if (locked) mutexTo.ReleaseMutex();
     }
 }));
 
-Task transfer = Task.Run(() =>
-{
+Task transfer = Task.Run(() => {
     Thread.Sleep(100); // just make sure transfer happens after Deposit and Withdraw
     bool locked = Mutex.WaitAll([mutexFrom, mutexTo]); // same as WaitHandle.WaitAll // [!code highlight] 
-    try
-    {
+    try {
         if (locked) BankAccount.Transfer(from, to, from.Balance);
-    }
-    finally
-    {
-        if (locked)
-        {
+    } finally {
+        if (locked) {
             // release all of them
             mutexFrom.ReleaseMutex(); // [!code highlight] 
             mutexTo.ReleaseMutex(); // [!code highlight] 
@@ -161,7 +137,7 @@ Console.WriteLine(to.Balance); // 0
 Global Mutex is created by Mutex constructor with a specified name.
 It's registered by it's name across the operating system.
 
-- Use `Mutex.OpenExisting` to open a registered glbal mutex by its name. 
+- Use `Mutex.OpenExisting` to open a registered global mutex by its name. 
     - This always returns a mutex represents the registered one.(the reference might be different)
     ```cs
     _ = Mutex.OpenExisting("Global\\..."); 
@@ -177,16 +153,12 @@ internal class Program
 
     const string MutexId = "Global\\149b89b4-3bc9-4df5-9064-5d28b4ae8ca4"; // must start with Global\ // [!code highlight] 
     static Mutex? mutex = null;
-    private static void Main(string[] args)
-    {
-        try
-        {
+    private static void Main(string[] args) {
+        try {
             // might throw here when mutex not registered with the name
             _ = Mutex.OpenExisting(MutexId); 
             Console.WriteLine($"{MutexId} is running, cannot start another instance.");
-        }
-        catch (WaitHandleCannotBeOpenedException)
-        {
+        } catch (WaitHandleCannotBeOpenedException) {
             mutex = new Mutex(false, MutexId); // register the mutex, `initiallyOwned` doesn't matter here
             Console.WriteLine("A unique instance is started");
         }
@@ -198,7 +170,7 @@ internal class Program
 ```
 
 > [!NOTE]
-> `Local\` is no required when creating a local mutex
+> `Local\` is not required when creating a local mutex
 
 ## Abandoned Mutex
 

…ynchronization/Monitor & lock Keyword.md …chronization/2.Monitor & lock Keyword.mddocs/document/Modern CSharp/docs/Parallel Programming/Synchronization/Monitor & lock Keyword.md renamed to docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/2.Monitor & lock Keyword.md docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/Monitor & lock Keyword.md renamed to docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/2.Monitor & lock Keyword.md

@@ -27,8 +27,7 @@ To start a job there's multiple approaches to do the same:
 _ = Task.Factory.StartNew(() => Console.WriteLine("hello"));
 _ = Task.Run(() => Console.WriteLine("hello"));
 
-var fooAsync = async () =>
-{
+var fooAsync = async () => {
     await Task.Run(() => Console.WriteLine("foo"));
 };
 
@@ -55,8 +54,7 @@ Both `TaskFactory` and `Task` supports an overload to accept **single argument**
 Since only single value is supported, you may need an abstraction when to pass multiple values
 
 ```cs
-_ = Task.Factory.StartNew((object foo) => // [!code highlight] 
-{
+_ = Task.Factory.StartNew((object foo) => {
     Console.WriteLine(foo.GetType());
 }, 123);
 
@@ -76,15 +74,13 @@ task.Start();
 Each `async` delegate is like a factory for it's dedicated action only.
 
 ```cs
-Func<Task> foo = async () =>
-{
+Func<Task> foo = async () => {
     await Task.Delay(100);
 };
 
 await foo();
 
-Func<int, Task<int>> bar = async (int number) =>
-{
+Func<int, Task<int>> bar = async (int number) => {
     await Task.Delay(1000);
     return number;
 };
@@ -95,8 +91,7 @@ bar(123).Wait();
 And it can be super useful when creating a batch of tasks using LINQ:
 
 ```cs
-_ = await Task.WhenAll(Enumerable.Range(1, 10).Select(async x =>
-{
+_ = await Task.WhenAll(Enumerable.Range(1, 10).Select(async x => {
     await Task.Delay(100);
     return x;
 }));
@@ -110,22 +105,19 @@ That is because, `async` delegate is a factory for dedicated task, so the result
 
 ```cs
 // note: it's a wrapped task
-Task<Task<int>> t = Task.Factory.StartNew(async () =>
-{
+Task<Task<int>> t = Task.Factory.StartNew(async () => {
     await Task.Delay(1000);
     return 42;
 });
 
 // use this instead!!
-Task<int> t2 = Task.Factory.StartNew(async () =>
-{
+Task<int> t2 = Task.Factory.StartNew(async () => {
     await Task.Delay(1000);
     return 42;
 }).Unwrap();
 
 // functionally you can use await to unwrap but it's definitely not recommended
-Task<int> t2 = await Task.Factory.StartNew(async () =>
-{
+Task<int> t2 = await Task.Factory.StartNew(async () => {
     await Task.Delay(1000);
     return 42;
 });
@@ -136,8 +128,7 @@ Task<int> t2 = await Task.Factory.StartNew(async () =>
 > `Task.Run` has a implicit auto-unwrap for some of its overloads, you may prefer this over `TaskFactory.StartNew` to start a simple task.
 >```cs
 >// The type is unwraped
->Task<int> t = Task.Run(async () =>
->{
+>Task<int> t = Task.Run(async () => {
 >    await Task.Delay(1000);
 >    return 42;
 >});
@@ -247,10 +238,8 @@ _ = Task.Factory.StartNew(
 - `Thread.Sleep`: pauses the thread and allows the scheduler to run another thread while sleeping, for the efficiency.
 - `SpinWait.SpinUntil`: pauses the thread until a condition fits. The scheduler are not allowed to run another thread using current resource of this thread.
     ```cs
-    Task task = new(() =>
-    {
-        SpinWait.SpinUntil(() =>
-        {
+    Task task = new(() => {
+        SpinWait.SpinUntil(() => {
             return true;
         }, 1000);
     });

…lel Programming/Synchronization/Mutex.md …l Programming/Synchronization/3.Mutex.mddocs/document/Modern CSharp/docs/Parallel Programming/Synchronization/Mutex.md renamed to docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/3.Mutex.md docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/Mutex.md renamed to docs/document/Modern CSharp/docs/Parallel Programming/Synchronization/3.Mutex.md

@@ -16,8 +16,7 @@ Waiting a task means the execution of code is synchronous but there's a essentia
 - `await` operator waits the task without blocking the calling thread.
     ```cs
     int foo = await Foo(); // does not block the main thread but still synchronous
-    static async Task<int> Foo 
-    {
+    static async Task<int> Foo {
         await Task.Delay(500);
         return 123;
     }
@@ -42,8 +41,7 @@ await task;
 Starting a simple task manually is quiet trivial so one should prefer `Task.Run` or `Task.Factory.StartNew`
 
 ```cs
-await Task.Factory.StartNew((object? foo) =>
-{
+await Task.Factory.StartNew((object? foo) => {
     Console.WriteLine(((dynamic)foo).Foo);
 }, new { Foo = 345 });
 
@@ -59,8 +57,7 @@ await Task.Run(() => { Console.WriteLine("hello"); });
 > `WhenAll` and `WhenAny` do not start tasks for you, make sure they're started before waiting.
 
 ```cs
-IEnumerable<Task<int>> tasks = Enumerable.Range(1, 10).Select(async x =>
-{
+IEnumerable<Task<int>> tasks = Enumerable.Range(1, 10).Select(async x => {
     await Task.Delay(x * 100);
     return x;
 });
@@ -77,32 +74,23 @@ Console.WriteLine(first.Result); // should be 1
 ```cs
 using CancellationTokenSource cts = new();
 var token = cts.Token;
-Task task = new Task(() =>
-{
+Task task = new Task(() => {
     int i = Random.Shared.Next(1, 5); // random countdown // [!code highlight] 
-    while (i-- > 0)
-    {
+    while (i-- > 0) {
         token.ThrowIfCancellationRequested();
         Console.WriteLine("operation...");
         Thread.Sleep(1000);
     }
 }, token);
 
-try
-{
+try {
     task.Start(); // [!code highlight] 
-    if (task == await Task.WhenAny(task, Task.Delay(3000))) // to race with the delay // [!code highlight] 
-    {
+    if (task == await Task.WhenAny(task, Task.Delay(3000))) { // to race with the delay // [!code highlight]
         Console.WriteLine("Task succeeded");
-    }
-    else
-    {
+    } else {
         cts.Cancel();
         Console.WriteLine("Task canceled for timeout");
     }
-}
-catch (OperationCanceledException)
-{
-}
+} catch (OperationCanceledException) { }
 ```