KEMBAR78
C# Advanced L04-Threading | PDF
Mohammad Shaker, profile picture
Uploaded byMohammad Shaker
PDF, PPTX1,275 views

C# Advanced L04-Threading

This document discusses threading and parallel programming in C#. It demonstrates how to use Parallel.For to execute a loop in parallel threads to improve performance. It also shows examples of potential threading issues like race conditions that can occur when accessing shared resources from multiple threads simultaneously without synchronization. The document presents solutions for race conditions using locks to synchronize access to shared resources.

Download as PDF, PPTX
Mohammad Shaker mohammadshaker.com @ZGTRShaker 2011, 2012, 2013, 2014 C# Advanced L04-THREADING
Threading
Concept of Threading •What is a “Thread”? –The advantage of threading is the ability to create applications that use more than one thread of execution. For example, a process can have a user interface thread that manages interactions with the user and worker threads that perform other tasks while the user interface thread waits for user input. •What’s this? for (int i = 1; i < 50; i++) { Console.SetWindowSize(i, i); System.Threading.Thread.Sleep(50); }
Let’s Parallel
Let’s Parallel class Program { private static void Main() { for (int i = 0; i < 10; i++) { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); } } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } }
Let’s Parallel class Program { private static void Main() { for (int i = 0; i < 10; i++) { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); } } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } } 0 -4999999950000000 1 -4999999950000000 2 -4999999950000000 3 -4999999950000000 4 -4999999950000000 5 -4999999950000000 6 -4999999950000000 7 -4999999950000000 8 -4999999950000000 9 -4999999950000000 Press any key to continue . . .
Let’s Parallel class Program { private static void Main() { for (int i = 0; i < 10; i++) { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); } } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } }
Let’s Parallel class Program { private static void Main() { Parallel.For(0, 10, i => { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); }); } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } }
Let’s Parallel class Program { private static void Main() { Parallel.For(0, 10, i => { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); }); } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } } 0 -4999999950000000 1 -4999999950000000 2 -4999999950000000 3 -4999999950000000 4 -4999999950000000 5 -4999999950000000 6 -4999999950000000 7 -4999999950000000 8 -4999999950000000 9 -4999999950000000 Press any key to continue . . . The Same Result but Much Faster
Parallel Task
Let’s Parallel 0 on Task 1 2 on Task 1 5 on Task 2 10 on Task 3 1 on Task 5 4 on Task 5 8 on Task 5 15 on Task 4 16 on Task 4 17 on Task 4 18 on Task 4 19 on Task 4 13 on Task 4 14 on Task 4 6 on Task 2 7 on Task 2 9 on Task 5 11 on Task 3 12 on Task 3 3 on Task 1 Press any key to continue . . . private void Test() { Parallel.For(0, 20, i=> Console.WriteLine("{0} on Task {1}", i, Task.CurrentId)); } 5different tasks working
Let’s Parallel 0 on Task 1 2 on Task 1 5 on Task 2 10 on Task 3 1 on Task 5 4 on Task 5 8 on Task 5 15 on Task 4 16 on Task 4 17 on Task 4 18 on Task 4 19 on Task 4 13 on Task 4 14 on Task 4 6 on Task 2 7 on Task 2 9 on Task 5 11 on Task 3 12 on Task 3 3 on Task 1 Press any key to continue . . . private void Test() { Parallel.For(0, 20, i=> Console.WriteLine("{0} on Task {1}", i, Task.CurrentId)); } 0 on Task 1 2 on Task 1 5 on Task 2 6 on Task 2 10 on Task 3 11 on Task 3 12 on Task 3 13 on Task 3 14 on Task 3 16 on Task 3 3 on Task 1 15 on Task 4 8 on Task 4 9 on Task 4 7 on Task 2 1 on Task 5 17 on Task 3 4 on Task 1 18 on Task 3 19 on Task 3 Press any key to continue . . . 0 on Task 1 1 on Task 1 5 on Task 2 6 on Task 2 7 on Task 2 8 on Task 2 9 on Task 2 11 on Task 2 12 on Task 2 13 on Task 2 15 on Task 4 16 on Task 4 17 on Task 4 18 on Task 4 19 on Task 4 2 on Task 1 4 on Task 4 14 on Task 2 10 on Task 3 3 on Task 5 Press any key to continue . . .
Let’s Parallel •The following: •Is the same as: private void Test() { Parallel.For(0, 20, i=> { Console.WriteLine("{0} on Task {1}", i, Task.CurrentId); }); } private void Test() { Parallel.For(0, 20, i=> Console.WriteLine("{0} on Task {1}", i, Task.CurrentId)); }
Let’s Parallel 0 on Task 1 1 on Task 1 2 on Task 1 3 on Task 1 4 on Task 1 5 on Task 1 6 on Task 1 7 on Task 1 8 on Task 1 10 on Task 2 11 on Task 2 12 on Task 2 13 on Task 2 14 on Task 2 15 on Task 2 16 on Task 2 9 on Task 1 17 on Task 2 18 on Task 2 19 on Task 2 Press any key to continue . . . ParallelOptionsparallelOptions= new ParallelOptions(); parallelOptions.MaxDegreeOfParallelism= 2; Parallel.For(0, 20, parallelOptions, i=> { Console.WriteLine("{0} on Task {1}", i, Task.CurrentId); }); 0 on Task 1 1 on Task 1 2 on Task 1 3 on Task 1 4 on Task 1 10 on Task 2 11 on Task 2 12 on Task 2 13 on Task 2 14 on Task 2 15 on Task 2 16 on Task 2 17 on Task 2 18 on Task 2 19 on Task 2 7 on Task 2 8 on Task 2 9 on Task 2 5 on Task 1 6 on Task 1 Press any key to continue . . . Limiting the number of tasks to just 2
Parallel.Invoke
Parallel.Invoke static void Main() { Parallel.Invoke( () => RunTask(1), () => RunTask(2), () => RunTask(3), () => RunTask(4), () => RunTask(5) ); } static void RunTask(inttaskNumber) { Console.WriteLine("Task {0} started", taskNumber); Console.WriteLine("Task {0} complete", taskNumber); }
Parallel.Invoke static void Main() { Parallel.Invoke( () => RunTask(1), () => RunTask(2), () => RunTask(3), () => RunTask(4), () => RunTask(5) ); } static void RunTask(inttaskNumber) { Console.WriteLine("Task {0} started", taskNumber); Console.WriteLine("Task {0} complete", taskNumber); } Task 2 started Task 2 complete Task 3 started Task 4 started Task 1 started Task 1 complete Task 3 complete Task 5 started Task 5 complete Task 4 complete Press any key to continue . . .
Parallel.Invoke static void Main() { Parallel.Invoke( () => RunTask(1), () => RunTask(2), () => RunTask(3), () => RunTask(4), () => RunTask(5) ); } static void RunTask(inttaskNumber) { Console.WriteLine("Task {0} started", taskNumber); Console.WriteLine("Task {0} complete", taskNumber); } Task 2 started Task 2 complete Task 3 started Task 4 started Task 1 started Task 1 complete Task 3 complete Task 5 started Task 5 complete Task 4 complete Press any key to continue . . . Use the following to limit the number of concurrent tasks: ParallelOptionsparallelOptions= new ParallelOptions(); parallelOptions.MaxDegreeOfParallelism= 2;
Threading Problems, like,
Threading Problems class Program { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } }
Threading Problems class Program { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } Incremented counter to 1. Decremented counter to -1. Final counter value is -1.
Threading Problems class Program { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } Incremented counter to 1. Decremented counter to -1. Final counter value is -1.
Threading Problems class Program { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } Incremented counter to 1. Decremented counter to -1. Final counter value is -1. Race Conditions
Racing ConditionsThe Solution
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions New
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions Shared object
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions Locking the shared object for each thread
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } The right output Incremented counter to 1. Decremented counter to 0. Final counter value is 0.
Lock (Object)
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Not good, don’t do this, or lock a string or etc.
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } The best choice for a locking object is a private or protected object defined within the class that controls the shared state.
ThreadClass
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } }
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Monitor Lock
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Acquire Lock
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Release Lock
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Final counter value is 0. Incremented counter to 1. Decremented counter to 0. Press any key to continue . . .
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Final counter value is 0. Incremented counter to 1. Decremented counter to 0. Press any key to continue . . . Why?
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); tAdd.Join(); tSub.Join(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Blocks the calling thread until the thread terminates
Threading Problems class Program { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); tAdd.Join(); tSub.Join(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Incremented counter to 1. Decremented counter to 0. Final counter value is 0. Press any key to continue . . . Blocks the calling thread until the thread terminates
Task.Factory varmyTask= Task.Factory.StartNew(() => { return "Hello, world!"; }); Console.WriteLine(myTask.Result);
TastWait
Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum());
Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); Will throw ArgumentNullExceptionbecause we are trying to use the array before it has been populated by the parallel task.
Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); Will throw ArgumentNullExceptionbecause we are trying to use the array before it has been populated by the parallel task. int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); loadDataTask.Wait(); loadDataTask.Dispose(); Console.WriteLine("Data total = {0}", values.Sum()); // Data total = 55
int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); loadDataTask.Wait(); loadDataTask.Dispose(); Console.WriteLine("Data total = {0}", values.Sum()); // Data total = 55 Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); To fix it, we will now waitfor the task to be done
int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); loadDataTask.Wait(); loadDataTask.Dispose(); Console.WriteLine("Data total = {0}", values.Sum()); Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); The output will be Data total = 55
Tasks Continuation Task continuation = firstTask.ContinueWith(antecedent => { /* functionality */ });

More Related Content

PDF
54240326 copy
byVinayak Shedgeri
 
PDF
ReactiveCocoa workshop
byEliasz Sawicki
 
PDF
Gevent be or not to be
byAleksandr Mokrov
 
PDF
The Future of Futures - A Talk About Java 8 CompletableFutures
byHaim Yadid
 
PPTX
Unit testing patterns for concurrent code
byDror Helper
 
PDF
Mutation @ Spotify
bySTAMP Project
 
PDF
The Ring programming language version 1.9 book - Part 48 of 210
byMahmoud Samir Fayed
 
ODP
Concurrent Programming in Java
byRuben Inoto Soto
 
54240326 copy
byVinayak Shedgeri
 
ReactiveCocoa workshop
byEliasz Sawicki
 
Gevent be or not to be
byAleksandr Mokrov
 
The Future of Futures - A Talk About Java 8 CompletableFutures
byHaim Yadid
 
Unit testing patterns for concurrent code
byDror Helper
 
Mutation @ Spotify
bySTAMP Project
 
The Ring programming language version 1.9 book - Part 48 of 210
byMahmoud Samir Fayed
 
Concurrent Programming in Java
byRuben Inoto Soto
 

What's hot

PPTX
CSharp for Unity Day2
byDuong Thanh
 
PDF
GenServer in action
byYurii Bodarev
 
PPTX
The secret unit testing tools no one ever told you about
byDror Helper
 
PPTX
Tools and Techniques for Understanding Threading Behavior in Android*
byIntel® Software
 
PDF
Completable future
bySrinivasan Raghvan
 
PDF
The Ring programming language version 1.6 book - Part 7 of 189
byMahmoud Samir Fayed
 
PPTX
From clever code to better code
byDror Helper
 
PPTX
Java весна 2013 лекция 2
byTechnopark
 
PDF
The Ring programming language version 1.6 book - Part 184 of 189
byMahmoud Samir Fayed
 
PDF
Leveraging Completable Futures to handle your query results Asynchrhonously
byDavid Gómez García
 
PDF
Actor Concurrency
byAlex Miller
 
PDF
The Ring programming language version 1.7 book - Part 85 of 196
byMahmoud Samir Fayed
 
PDF
STAMP Descartes Presentation
bySTAMP Project
 
PDF
The Ring programming language version 1.8 book - Part 32 of 202
byMahmoud Samir Fayed
 
PDF
Java 7 LavaJUG
byjulien.ponge
 
PDF
The Ring programming language version 1.8 book - Part 88 of 202
byMahmoud Samir Fayed
 
PDF
Java 7 Launch Event at LyonJUG, Lyon France. Fork / Join framework and Projec...
byjulien.ponge
 
CSharp for Unity Day2
byDuong Thanh
 
GenServer in action
byYurii Bodarev
 
The secret unit testing tools no one ever told you about
byDror Helper
 
Tools and Techniques for Understanding Threading Behavior in Android*
byIntel® Software
 
Completable future
bySrinivasan Raghvan
 
The Ring programming language version 1.6 book - Part 7 of 189
byMahmoud Samir Fayed
 
From clever code to better code
byDror Helper
 
Java весна 2013 лекция 2
byTechnopark
 
The Ring programming language version 1.6 book - Part 184 of 189
byMahmoud Samir Fayed
 
Leveraging Completable Futures to handle your query results Asynchrhonously
byDavid Gómez García
 
Actor Concurrency
byAlex Miller
 
The Ring programming language version 1.7 book - Part 85 of 196
byMahmoud Samir Fayed
 
STAMP Descartes Presentation
bySTAMP Project
 
The Ring programming language version 1.8 book - Part 32 of 202
byMahmoud Samir Fayed
 
Java 7 LavaJUG
byjulien.ponge
 
The Ring programming language version 1.8 book - Part 88 of 202
byMahmoud Samir Fayed
 
Java 7 Launch Event at LyonJUG, Lyon France. Fork / Join framework and Projec...
byjulien.ponge
 

Viewers also liked

PDF
Threading in c#
bygohsiauken
 
PPTX
Threading
byabhay singh
 
PPTX
multi threading
byYaswanth Babu Gummadivelli
 
PPTX
Threading in C#
byMedhat Dawoud
 
PPT
Threads c sharp
byKarthick Suresh
 
PPTX
Multi threading design pattern
byYan Wang
 
PDF
Real time web
byMedhat Dawoud
 
PDF
Thread
byMustafa Ugur Oduncu
 
PPS
07 iec t1_s1_oo_ps_session_10
byNiit Care
 
PPT
Threads c sharp
byDeivaa
 
PPT
Intro To .Net Threads
byrchakra
 
PPTX
Generics C#
byRaghuveer Guthikonda
 
PPTX
Multithreading Design Patterns
byPostSharp Technologies
 
PDF
C# Delegates and Event Handling
byJussi Pohjolainen
 
PPTX
Delegates and events
byGayathri Ganesh
 
ODP
Multithreading 101
byTim Penhey
 
PDF
Multithreading done right
byPlatonov Sergey
 
Threading in c#
bygohsiauken
 
Threading
byabhay singh
 
multi threading
byYaswanth Babu Gummadivelli
 
Threading in C#
byMedhat Dawoud
 
Threads c sharp
byKarthick Suresh
 
Multi threading design pattern
byYan Wang
 
Real time web
byMedhat Dawoud
 
Thread
byMustafa Ugur Oduncu
 
07 iec t1_s1_oo_ps_session_10
byNiit Care
 
Threads c sharp
byDeivaa
 
Intro To .Net Threads
byrchakra
 
Generics C#
byRaghuveer Guthikonda
 
Multithreading Design Patterns
byPostSharp Technologies
 
C# Delegates and Event Handling
byJussi Pohjolainen
 
Delegates and events
byGayathri Ganesh
 
Multithreading 101
byTim Penhey
 
Multithreading done right
byPlatonov Sergey
 

Similar to C# Advanced L04-Threading

PPTX
.NET Multithreading/Multitasking
bySasha Kravchuk
 
PPTX
Multi core programming 1
byRobin Aggarwal
 
PPTX
Parallel Processing
byRTigger
 
DOCX
Parallel Programming With Dot Net
byNeeraj Kaushik
 
PPTX
Async and parallel patterns and application design - TechDays2013 NL
byArie Leeuwesteijn
 
PPTX
Dot net parallelism and multicore computing
byAravindhan Gnanam
 
PPTX
Multi core programming 2
byRobin Aggarwal
 
ZIP
.Net 4.0 Threading and Parallel Programming
byAlex Moore
 
PDF
.NET Multithreading and File I/O
byJussi Pohjolainen
 
PDF
Concurrency and parallel in .net
byMohammad Hossein Karami
 
PPTX
Coding For Cores - C# Way
byBishnu Rawal
 
PPTX
concurrency_c#_public
byPaul Churchward
 
PDF
.Net Multithreading and Parallelization
byDmitri Nesteruk
 
PPTX
Parallel programming patterns (UA)
byOleksandr Pavlyshak
 
PPTX
Parallel programming patterns - Олександр Павлишак
byIgor Bronovskyy
 
PDF
delegates
byOwais Masood
 
PDF
Task Parallel Library (TPL)
byMuhammad Zaid Sarfraz
 
PPTX
Using Parallel Computing Platform - NHDNUG
byNorth Houston .NET Users Group
 
PPT
Parallel Extentions to the .NET Framework
byukdpe
 
PPTX
What's new in Visual Studio 2012 General
byNoam Sheffer
 
.NET Multithreading/Multitasking
bySasha Kravchuk
 
Multi core programming 1
byRobin Aggarwal
 
Parallel Processing
byRTigger
 
Parallel Programming With Dot Net
byNeeraj Kaushik
 
Async and parallel patterns and application design - TechDays2013 NL
byArie Leeuwesteijn
 
Dot net parallelism and multicore computing
byAravindhan Gnanam
 
Multi core programming 2
byRobin Aggarwal
 
.Net 4.0 Threading and Parallel Programming
byAlex Moore
 
.NET Multithreading and File I/O
byJussi Pohjolainen
 
Concurrency and parallel in .net
byMohammad Hossein Karami
 
Coding For Cores - C# Way
byBishnu Rawal
 
concurrency_c#_public
byPaul Churchward
 
.Net Multithreading and Parallelization
byDmitri Nesteruk
 
Parallel programming patterns (UA)
byOleksandr Pavlyshak
 
Parallel programming patterns - Олександр Павлишак
byIgor Bronovskyy
 
delegates
byOwais Masood
 
Task Parallel Library (TPL)
byMuhammad Zaid Sarfraz
 
Using Parallel Computing Platform - NHDNUG
byNorth Houston .NET Users Group
 
Parallel Extentions to the .NET Framework
byukdpe
 
What's new in Visual Studio 2012 General
byNoam Sheffer
 

More from Mohammad Shaker

PDF
12 Rules You Should to Know as a Syrian Graduate
byMohammad Shaker
 
PDF
Ultra Fast, Cross Genre, Procedural Content Generation in Games [Master Thesis]
byMohammad Shaker
 
PDF
Interaction Design L06 - Tricks with Psychology
byMohammad Shaker
 
PDF
Short, Matters, Love - Passioneers Event 2015
byMohammad Shaker
 
PDF
Unity L01 - Game Development
byMohammad Shaker
 
PDF
Android L07 - Touch, Screen and Wearables
byMohammad Shaker
 
PDF
Interaction Design L03 - Color
byMohammad Shaker
 
PDF
Interaction Design L05 - Typography
byMohammad Shaker
 
PDF
Interaction Design L04 - Materialise and Coupling
byMohammad Shaker
 
PDF
Android L05 - Storage
byMohammad Shaker
 
PDF
Android L04 - Notifications and Threading
byMohammad Shaker
 
PDF
Android L09 - Windows Phone and iOS
byMohammad Shaker
 
PDF
Interaction Design L01 - Mobile Constraints
byMohammad Shaker
 
PDF
Interaction Design L02 - Pragnanz and Grids
byMohammad Shaker
 
PDF
Android L10 - Stores and Gaming
byMohammad Shaker
 
PDF
Android L06 - Cloud / Parse
byMohammad Shaker
 
PDF
Android L08 - Google Maps and Utilities
byMohammad Shaker
 
PDF
Android L03 - Styles and Themes
byMohammad Shaker
 
PDF
Android L02 - Activities and Adapters
byMohammad Shaker
 
PDF
Android L01 - Warm Up
byMohammad Shaker
 
12 Rules You Should to Know as a Syrian Graduate
byMohammad Shaker
 
Ultra Fast, Cross Genre, Procedural Content Generation in Games [Master Thesis]
byMohammad Shaker
 
Interaction Design L06 - Tricks with Psychology
byMohammad Shaker
 
Short, Matters, Love - Passioneers Event 2015
byMohammad Shaker
 
Unity L01 - Game Development
byMohammad Shaker
 
Android L07 - Touch, Screen and Wearables
byMohammad Shaker
 
Interaction Design L03 - Color
byMohammad Shaker
 
Interaction Design L05 - Typography
byMohammad Shaker
 
Interaction Design L04 - Materialise and Coupling
byMohammad Shaker
 
Android L05 - Storage
byMohammad Shaker
 
Android L04 - Notifications and Threading
byMohammad Shaker
 
Android L09 - Windows Phone and iOS
byMohammad Shaker
 
Interaction Design L01 - Mobile Constraints
byMohammad Shaker
 
Interaction Design L02 - Pragnanz and Grids
byMohammad Shaker
 
Android L10 - Stores and Gaming
byMohammad Shaker
 
Android L06 - Cloud / Parse
byMohammad Shaker
 
Android L08 - Google Maps and Utilities
byMohammad Shaker
 
Android L03 - Styles and Themes
byMohammad Shaker
 
Android L02 - Activities and Adapters
byMohammad Shaker
 
Android L01 - Warm Up
byMohammad Shaker
 

Recently uploaded

PDF
The 50+ First-Timer: My OpenTelemetry Contribution and How Your CNCF Journey...
byImma Valls Bernaus
 
PDF
Where Does Your Data Go When You Put In Into A Database_.pdf
byDave Stokes
 
PDF
SAP & CTRM Testing Like Never Before
byZoe Gilbert
 
PPTX
Integrated Billing, Accounting & Inventory Solution for MSMEs
byMoving Cloud
 
PDF
Metrics, logs, traces, and mayhem_ introducing an observability adventure gam...
byImma Valls Bernaus
 
PDF
How can AI be used in Content Management Systems, Plone Conference 2025
byRob Gietema
 
PDF
How QuickHR Helps SMEs Control Expense Claims
byParker adam
 
PDF
Dreamforce 2025: Welcome to the Agentic Enterprise
byDele Amefo
 
PDF
Scraping Amazon Prime Watchlist Data for Viewing Patterns.pdf
byyashpatric
 
PDF
VADY Smart Data Flow – Automated Data Insights for Scalable Enterprise Decisions
byNewFangledVision
 
PDF
Zoho Vani AI-Powered Collaboration Platform to Rival Google Workspace & Micro...
byEvoluz Global Solutions
 
PDF
VADY GenAI – Enterprise AI Solutions with Complete Data Control and Smart Dec...
byNewFangledVision
 
PPT
Evolution of the Major Programming Languages
bymjmansoori54
 
DOCX
Best Tableau Alternatives for Data Analytics and Reporting.docx
byVarsha Nayak
 
PPTX
Systems Programming Lecture Compute.pptx
byAdekunle25
 
PDF
The new Volto Form Block, Plone Conference 2025
byRob Gietema
 
PDF
Driving Stress Detection Using Multimodal CNN with Nonlinear Representation o...
byPranjal Kumar
 
PPTX
Standardization of open-source software ISO/IEC 5230:2020 and ISO/IEC 18974:2...
byShane Coughlan
 
PDF
Ensuring Regulatory Excellence with Insurance Compliance Software
byInsurance Tech Services
 
PPTX
Validation testing in software engineering
bytanzeelamohsin01
 
The 50+ First-Timer: My OpenTelemetry Contribution and How Your CNCF Journey...
byImma Valls Bernaus
 
Where Does Your Data Go When You Put In Into A Database_.pdf
byDave Stokes
 
SAP & CTRM Testing Like Never Before
byZoe Gilbert
 
Integrated Billing, Accounting & Inventory Solution for MSMEs
byMoving Cloud
 
Metrics, logs, traces, and mayhem_ introducing an observability adventure gam...
byImma Valls Bernaus
 
How can AI be used in Content Management Systems, Plone Conference 2025
byRob Gietema
 
How QuickHR Helps SMEs Control Expense Claims
byParker adam
 
Dreamforce 2025: Welcome to the Agentic Enterprise
byDele Amefo
 
Scraping Amazon Prime Watchlist Data for Viewing Patterns.pdf
byyashpatric
 
VADY Smart Data Flow – Automated Data Insights for Scalable Enterprise Decisions
byNewFangledVision
 
Zoho Vani AI-Powered Collaboration Platform to Rival Google Workspace & Micro...
byEvoluz Global Solutions
 
VADY GenAI – Enterprise AI Solutions with Complete Data Control and Smart Dec...
byNewFangledVision
 
Evolution of the Major Programming Languages
bymjmansoori54
 
Best Tableau Alternatives for Data Analytics and Reporting.docx
byVarsha Nayak
 
Systems Programming Lecture Compute.pptx
byAdekunle25
 
The new Volto Form Block, Plone Conference 2025
byRob Gietema
 
Driving Stress Detection Using Multimodal CNN with Nonlinear Representation o...
byPranjal Kumar
 
Standardization of open-source software ISO/IEC 5230:2020 and ISO/IEC 18974:2...
byShane Coughlan
 
Ensuring Regulatory Excellence with Insurance Compliance Software
byInsurance Tech Services
 
Validation testing in software engineering
bytanzeelamohsin01
 

C# Advanced L04-Threading

  • 1.
    Mohammad Shaker mohammadshaker.com @ZGTRShaker 2011, 2012, 2013, 2014 C# Advanced L04-THREADING
  • 2.
  • 3.
    Concept of Threading •What is a “Thread”? –The advantage of threading is the ability to create applications that use more than one thread of execution. For example, a process can have a user interface thread that manages interactions with the user and worker threads that perform other tasks while the user interface thread waits for user input. •What’s this? for (int i = 1; i < 50; i++) { Console.SetWindowSize(i, i); System.Threading.Thread.Sleep(50); }
  • 4.
  • 5.
    Let’s Parallel classProgram { private static void Main() { for (int i = 0; i < 10; i++) { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); } } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } }
  • 6.
    Let’s Parallel classProgram { private static void Main() { for (int i = 0; i < 10; i++) { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); } } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } } 0 -4999999950000000 1 -4999999950000000 2 -4999999950000000 3 -4999999950000000 4 -4999999950000000 5 -4999999950000000 6 -4999999950000000 7 -4999999950000000 8 -4999999950000000 9 -4999999950000000 Press any key to continue . . .
  • 7.
    Let’s Parallel classProgram { private static void Main() { for (int i = 0; i < 10; i++) { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); } } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } }
  • 8.
    Let’s Parallel classProgram { private static void Main() { Parallel.For(0, 10, i => { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); }); } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } }
  • 9.
    Let’s Parallel classProgram { private static void Main() { Parallel.For(0, 10, i => { long total = GetTotal(); Console.WriteLine("{0} -{1}", i, total); }); } private static long GetTotal() { long total = 0; for (inti= 1; i< 100000000; i++) { total += i; } return total; } } 0 -4999999950000000 1 -4999999950000000 2 -4999999950000000 3 -4999999950000000 4 -4999999950000000 5 -4999999950000000 6 -4999999950000000 7 -4999999950000000 8 -4999999950000000 9 -4999999950000000 Press any key to continue . . . The Same Result but Much Faster
  • 10.
  • 11.
    Let’s Parallel 0on Task 1 2 on Task 1 5 on Task 2 10 on Task 3 1 on Task 5 4 on Task 5 8 on Task 5 15 on Task 4 16 on Task 4 17 on Task 4 18 on Task 4 19 on Task 4 13 on Task 4 14 on Task 4 6 on Task 2 7 on Task 2 9 on Task 5 11 on Task 3 12 on Task 3 3 on Task 1 Press any key to continue . . . private void Test() { Parallel.For(0, 20, i=> Console.WriteLine("{0} on Task {1}", i, Task.CurrentId)); } 5different tasks working
  • 12.
    Let’s Parallel 0on Task 1 2 on Task 1 5 on Task 2 10 on Task 3 1 on Task 5 4 on Task 5 8 on Task 5 15 on Task 4 16 on Task 4 17 on Task 4 18 on Task 4 19 on Task 4 13 on Task 4 14 on Task 4 6 on Task 2 7 on Task 2 9 on Task 5 11 on Task 3 12 on Task 3 3 on Task 1 Press any key to continue . . . private void Test() { Parallel.For(0, 20, i=> Console.WriteLine("{0} on Task {1}", i, Task.CurrentId)); } 0 on Task 1 2 on Task 1 5 on Task 2 6 on Task 2 10 on Task 3 11 on Task 3 12 on Task 3 13 on Task 3 14 on Task 3 16 on Task 3 3 on Task 1 15 on Task 4 8 on Task 4 9 on Task 4 7 on Task 2 1 on Task 5 17 on Task 3 4 on Task 1 18 on Task 3 19 on Task 3 Press any key to continue . . . 0 on Task 1 1 on Task 1 5 on Task 2 6 on Task 2 7 on Task 2 8 on Task 2 9 on Task 2 11 on Task 2 12 on Task 2 13 on Task 2 15 on Task 4 16 on Task 4 17 on Task 4 18 on Task 4 19 on Task 4 2 on Task 1 4 on Task 4 14 on Task 2 10 on Task 3 3 on Task 5 Press any key to continue . . .
  • 13.
    Let’s Parallel •Thefollowing: •Is the same as: private void Test() { Parallel.For(0, 20, i=> { Console.WriteLine("{0} on Task {1}", i, Task.CurrentId); }); } private void Test() { Parallel.For(0, 20, i=> Console.WriteLine("{0} on Task {1}", i, Task.CurrentId)); }
  • 14.
    Let’s Parallel 0on Task 1 1 on Task 1 2 on Task 1 3 on Task 1 4 on Task 1 5 on Task 1 6 on Task 1 7 on Task 1 8 on Task 1 10 on Task 2 11 on Task 2 12 on Task 2 13 on Task 2 14 on Task 2 15 on Task 2 16 on Task 2 9 on Task 1 17 on Task 2 18 on Task 2 19 on Task 2 Press any key to continue . . . ParallelOptionsparallelOptions= new ParallelOptions(); parallelOptions.MaxDegreeOfParallelism= 2; Parallel.For(0, 20, parallelOptions, i=> { Console.WriteLine("{0} on Task {1}", i, Task.CurrentId); }); 0 on Task 1 1 on Task 1 2 on Task 1 3 on Task 1 4 on Task 1 10 on Task 2 11 on Task 2 12 on Task 2 13 on Task 2 14 on Task 2 15 on Task 2 16 on Task 2 17 on Task 2 18 on Task 2 19 on Task 2 7 on Task 2 8 on Task 2 9 on Task 2 5 on Task 1 6 on Task 1 Press any key to continue . . . Limiting the number of tasks to just 2
  • 15.
  • 16.
    Parallel.Invoke static voidMain() { Parallel.Invoke( () => RunTask(1), () => RunTask(2), () => RunTask(3), () => RunTask(4), () => RunTask(5) ); } static void RunTask(inttaskNumber) { Console.WriteLine("Task {0} started", taskNumber); Console.WriteLine("Task {0} complete", taskNumber); }
  • 17.
    Parallel.Invoke static voidMain() { Parallel.Invoke( () => RunTask(1), () => RunTask(2), () => RunTask(3), () => RunTask(4), () => RunTask(5) ); } static void RunTask(inttaskNumber) { Console.WriteLine("Task {0} started", taskNumber); Console.WriteLine("Task {0} complete", taskNumber); } Task 2 started Task 2 complete Task 3 started Task 4 started Task 1 started Task 1 complete Task 3 complete Task 5 started Task 5 complete Task 4 complete Press any key to continue . . .
  • 18.
    Parallel.Invoke static voidMain() { Parallel.Invoke( () => RunTask(1), () => RunTask(2), () => RunTask(3), () => RunTask(4), () => RunTask(5) ); } static void RunTask(inttaskNumber) { Console.WriteLine("Task {0} started", taskNumber); Console.WriteLine("Task {0} complete", taskNumber); } Task 2 started Task 2 complete Task 3 started Task 4 started Task 1 started Task 1 complete Task 3 complete Task 5 started Task 5 complete Task 4 complete Press any key to continue . . . Use the following to limit the number of concurrent tasks: ParallelOptionsparallelOptions= new ParallelOptions(); parallelOptions.MaxDegreeOfParallelism= 2;
  • 19.
  • 20.
    Threading Problems classProgram { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } }
  • 21.
    Threading Problems classProgram { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } Incremented counter to 1. Decremented counter to -1. Final counter value is -1.
  • 22.
    Threading Problems classProgram { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } Incremented counter to 1. Decremented counter to -1. Final counter value is -1.
  • 23.
    Threading Problems classProgram { static int_counter = 0; static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } static void SubtractOne() { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } Incremented counter to 1. Decremented counter to -1. Final counter value is -1. Race Conditions
  • 24.
  • 25.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions
  • 26.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions New
  • 27.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions Shared object
  • 28.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Race Conditions Locking the shared object for each thread
  • 29.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } The right output Incremented counter to 1. Decremented counter to 0. Final counter value is 0.
  • 30.
  • 31.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } Not good, don’t do this, or lock a string or etc.
  • 32.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); static void Main(string[] args) { Parallel.Invoke(AddOne, SubtractOne); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { lock (_lock) { inttemp = _counter; temp++; Thread.Sleep(2000); Console.WriteLine("Incremented counter to {0}.", temp); _counter = temp; } } static void SubtractOne() { lock (_lock) { inttemp = _counter; temp--; Thread.Sleep(2000); Console.WriteLine("Decremented counter to {0}.", temp); _counter = temp; } } } The best choice for a locking object is a private or protected object defined within the class that controls the shared state.
  • 33.
  • 34.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } }
  • 35.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Monitor Lock
  • 36.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Acquire Lock
  • 37.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Release Lock
  • 38.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Final counter value is 0. Incremented counter to 1. Decremented counter to 0. Press any key to continue . . .
  • 39.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Final counter value is 0. Incremented counter to 1. Decremented counter to 0. Press any key to continue . . . Why?
  • 40.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); tAdd.Join(); tSub.Join(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Blocks the calling thread until the thread terminates
  • 41.
    Threading Problems classProgram { static int_counter = 0; static object _lock = new object(); constintsleepAmount= 500; static void Main(string[] args) { Thread tAdd= new Thread(AddOne); Thread tSub= new Thread(SubtractOne); tAdd.Start(); tSub.Start(); tAdd.Join(); tSub.Join(); Console.WriteLine("Final counter value is {0}.", _counter); } static void AddOne() { Monitor.Enter(_lock); try { _counter++; Thread.Sleep(sleepAmount); Console.WriteLine("Incremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } static void SubtractOne() { Monitor.Enter(_lock); try { _counter--; Thread.Sleep(sleepAmount); Console.WriteLine("Decremented counter to {0}.", _counter); } finally { Monitor.Exit(_lock); } } } } Incremented counter to 1. Decremented counter to 0. Final counter value is 0. Press any key to continue . . . Blocks the calling thread until the thread terminates
  • 42.
    Task.Factory varmyTask= Task.Factory.StartNew(()=> { return "Hello, world!"; }); Console.WriteLine(myTask.Result);
  • 43.
  • 44.
    Wait int[] values= null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum());
  • 45.
    Wait int[] values= null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); Will throw ArgumentNullExceptionbecause we are trying to use the array before it has been populated by the parallel task.
  • 46.
    Wait int[] values= null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); Will throw ArgumentNullExceptionbecause we are trying to use the array before it has been populated by the parallel task. int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); loadDataTask.Wait(); loadDataTask.Dispose(); Console.WriteLine("Data total = {0}", values.Sum()); // Data total = 55
  • 47.
    int[] values =null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); loadDataTask.Wait(); loadDataTask.Dispose(); Console.WriteLine("Data total = {0}", values.Sum()); // Data total = 55 Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); To fix it, we will now waitfor the task to be done
  • 48.
    int[] values =null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); loadDataTask.Wait(); loadDataTask.Dispose(); Console.WriteLine("Data total = {0}", values.Sum()); Wait int[] values = null; Task loadDataTask= new Task(() => { Console.WriteLine("Loading data..."); Thread.Sleep(5000); values = Enumerable.Range(1,10).ToArray(); }); loadDataTask.Start(); Console.WriteLine("Data total = {0}", values.Sum()); The output will be Data total = 55
  • 49.
    Tasks Continuation Taskcontinuation = firstTask.ContinueWith(antecedent => { /* functionality */ });