using System;
using System.Threading;
using static System.Console;
namespace Chapter1.Recipe1
{
class Program
{
static void Main(string[] args)
{
Thread t = new Thread(PrintNumbers);
t.Start();
PrintNumbers();
}
static void PrintNumbers()
{
WriteLine("Starting...");
for (int i = 1; i < 10; i++)
{
WriteLine(i);
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe2
{
class Program
{
static void Main(string[] args)
{
Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
PrintNumbers();
}
static void PrintNumbers()
{
WriteLine("Starting...");
for (int i = 1; i < 10; i++)
{
WriteLine(i);
}
}
static void PrintNumbersWithDelay()
{
WriteLine("Starting...");
for (int i = 1; i < 10; i++)
{
Sleep(TimeSpan.FromSeconds(2));
WriteLine(i);
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe3
{
class Program
{
static void Main(string[] args)
{
WriteLine("Starting program...");
Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
t.Join();
WriteLine("Thread completed");
}
static void PrintNumbersWithDelay()
{
WriteLine("Starting...");
for (int i = 1; i < 10; i++)
{
Sleep(TimeSpan.FromSeconds(2));
WriteLine(i);
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe4
{
class Program
{
static void Main(string[] args)
{
WriteLine("Starting program...");
Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
Sleep(TimeSpan.FromSeconds(6));
t.Abort();
WriteLine("A thread has been aborted");
}
static void PrintNumbersWithDelay()
{
WriteLine("Starting...");
for (int i = 1; i < 10; i++)
{
Sleep(TimeSpan.FromSeconds(2));
WriteLine(i);
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe5
{
class Program
{
static void Main(string[] args)
{
WriteLine("Starting program...");
Thread t = new Thread(PrintNumbersWithStatus);
Thread t2 = new Thread(DoNothing);
WriteLine(t.ThreadState.ToString());
t2.Start();
t.Start();
for (int i = 1; i < 30; i++)
{
WriteLine(t.ThreadState.ToString());
}
Sleep(TimeSpan.FromSeconds(6));
t.Abort();
WriteLine("A thread has been aborted");
WriteLine(t.ThreadState.ToString());
WriteLine(t2.ThreadState.ToString());
}
static void DoNothing()
{
Sleep(TimeSpan.FromSeconds(2));
}
static void PrintNumbersWithStatus()
{
WriteLine("Starting...");
WriteLine(CurrentThread.ThreadState.ToString());
for (int i = 1; i < 10; i++)
{
Sleep(TimeSpan.FromSeconds(2));
WriteLine(i);
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
using static System.Diagnostics.Process;
namespace Chapter1.Recipe6
{
class Program
{
static void Main(string[] args)
{
WriteLine($"Current thread priority: {CurrentThread.Priority}");
WriteLine("Running on all cores available");
RunThreads();
Sleep(TimeSpan.FromSeconds(2));
WriteLine("Running on a single core");
GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
RunThreads();
}
static void RunThreads()
{
var sample = new ThreadSample();
var threadOne = new Thread(sample.CountNumbers);
threadOne.Name = "ThreadOne";
var threadTwo = new Thread(sample.CountNumbers);
threadTwo.Name = "ThreadTwo";
threadOne.Priority = ThreadPriority.Highest;
threadTwo.Priority = ThreadPriority.Lowest;
threadOne.Start();
threadTwo.Start();
Sleep(TimeSpan.FromSeconds(2));
sample.Stop();
}
class ThreadSample
{
private bool _isStopped = false;
public void Stop()
{
_isStopped = true;
}
public void CountNumbers()
{
long counter = 0;
while (!_isStopped)
{
counter++;
}
WriteLine($"{CurrentThread.Name} with " +
$"{CurrentThread.Priority,11} priority " +
$"has a count = {counter,13:N0}");
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe7
{
class Program
{
static void Main(string[] args)
{
var sampleForeground = new ThreadSample(10);
var sampleBackground = new ThreadSample(20);
var threadOne = new Thread(sampleForeground.CountNumbers);
threadOne.Name = "ForegroundThread";
var threadTwo = new Thread(sampleBackground.CountNumbers);
threadTwo.Name = "BackgroundThread";
threadTwo.IsBackground = true;
threadOne.Start();
threadTwo.Start();
}
class ThreadSample
{
private readonly int _iterations;
public ThreadSample(int iterations)
{
_iterations = iterations;
}
public void CountNumbers()
{
for (int i = 0; i < _iterations; i++)
{
Sleep(TimeSpan.FromSeconds(0.5));
WriteLine($"{CurrentThread.Name} prints {i}");
}
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe8
{
class Program
{
static void Main(string[] args)
{
var sample = new ThreadSample(10);
var threadOne = new Thread(sample.CountNumbers);
threadOne.Name = "ThreadOne";
threadOne.Start();
threadOne.Join();
WriteLine("--------------------------");
var threadTwo = new Thread(Count);
threadTwo.Name = "ThreadTwo";
threadTwo.Start(8);
threadTwo.Join();
WriteLine("--------------------------");
var threadThree = new Thread(() => CountNumbers(12));
threadThree.Name = "ThreadThree";
threadThree.Start();
threadThree.Join();
WriteLine("--------------------------");
int i = 10;
var threadFour = new Thread(() => PrintNumber(i));
i = 20;
var threadFive = new Thread(() => PrintNumber(i));
threadFour.Start();
threadFive.Start();
}
static void Count(object iterations)
{
CountNumbers((int)iterations);
}
static void CountNumbers(int iterations)
{
for (int i = 1; i <= iterations; i++)
{
Sleep(TimeSpan.FromSeconds(0.5));
WriteLine($"{CurrentThread.Name} prints {i}");
}
}
static void PrintNumber(int number)
{
WriteLine(number);
}
class ThreadSample
{
private readonly int _iterations;
public ThreadSample(int iterations)
{
_iterations = iterations;
}
public void CountNumbers()
{
for (int i = 1; i <= _iterations; i++)
{
Sleep(TimeSpan.FromSeconds(0.5));
WriteLine($"{CurrentThread.Name} prints {i}");
}
}
}
}
}
using System;
using System.Threading;
using static System.Console;
namespace Chapter1.Recipe9
{
class Program
{
static void Main(string[] args)
{
WriteLine("Incorrect counter");
var c = new Counter();
var t1 = new Thread(() => TestCounter(c));
var t2 = new Thread(() => TestCounter(c));
var t3 = new Thread(() => TestCounter(c));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
WriteLine($"Total count: {c.Count}");
WriteLine("--------------------------");
WriteLine("Correct counter");
var c1 = new CounterWithLock();
t1 = new Thread(() => TestCounter(c1));
t2 = new Thread(() => TestCounter(c1));
t3 = new Thread(() => TestCounter(c1));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
WriteLine($"Total count: {c1.Count}");
}
static void TestCounter(CounterBase c)
{
for (int i = 0; i < 100000; i++)
{
c.Increment();
c.Decrement();
}
}
class Counter : CounterBase
{
public int Count { get; private set; }
public override void Increment()
{
Count++;
}
public override void Decrement()
{
Count--;
}
}
class CounterWithLock : CounterBase
{
private readonly object _syncRoot = new Object();
public int Count { get; private set; }
public override void Increment()
{
lock (_syncRoot)
{
Count++;
}
}
public override void Decrement()
{
lock (_syncRoot)
{
Count--;
}
}
}
abstract class CounterBase
{
public abstract void Increment();
public abstract void Decrement();
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe10
{
class Program
{
static void Main(string[] args)
{
object lock1 = new object();
object lock2 = new object();
new Thread(() => LockTooMuch(lock1, lock2)).Start();
lock (lock2)
{
Thread.Sleep(1000);
WriteLine("Monitor.TryEnter allows not to get stuck, returning false after a specified timeout is elapsed");
if (Monitor.TryEnter(lock1, TimeSpan.FromSeconds(5)))
{
WriteLine("Acquired a protected resource succesfully");
}
else
{
WriteLine("Timeout acquiring a resource!");
}
}
new Thread(() => LockTooMuch(lock1, lock2)).Start();
WriteLine("----------------------------------");
lock (lock2)
{
WriteLine("This will be a deadlock!");
Sleep(1000);
lock (lock1)
{
WriteLine("Acquired a protected resource succesfully");
}
}
}
static void LockTooMuch(object lock1, object lock2)
{
lock (lock1)
{
Sleep(1000);
lock (lock2);
}
}
}
}
using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
namespace Chapter1.Recipe11
{
class Program
{
static void Main(string[] args)
{
var t = new Thread(FaultyThread);
t.Start();
t.Join();
try
{
t = new Thread(BadFaultyThread);
t.Start();
}
catch (Exception ex)
{
WriteLine("We won't get here!");
}
}
static void BadFaultyThread()
{
WriteLine("Starting a faulty thread...");
Sleep(TimeSpan.FromSeconds(2));
throw new Exception("Boom!");
}
static void FaultyThread()
{
try
{
WriteLine("Starting a faulty thread...");
Sleep(TimeSpan.FromSeconds(1));
throw new Exception("Boom!");
}
catch (Exception ex)
{
WriteLine($"Exception handled: {ex.Message}");
}
}
}
}