1.1   Instructor

César Rodríguez (http://lipn.univ-paris13.fr/~rodriguez)

1.2   Syllabus and Program

Day 1: Multithreaded programming

• Creating and destroying threads
• Passing data to threads
• Thread synchronization: Monitors, locks, WaitHandles, CountdownEvent, the ThreadPool

Day 2: Network programming

• The Sockets API: client API, server API
• Above the socket layer: classes TcpClient, TcpServer, UdpClient

Day 3: Windows

• The Windows registry
• Event logs
• Windows Services

1.3   Attendance, Grading, and other Policies

Our school publishes every year an updated version of the document "Modalités de contrôle de connaissances" (MCC). The MCC contains rules and policies applicable to this course, read them (starting from p. 106). The rules below in this section recall the basic principles of the MCC and extend the MCC when appropriate for this course.

Attendance. Attendance to all the course sessions is mandatory and will be accounted for the final grade of the course. The absence to a session (lecture or practical) can be justified with appropriate documents, such as medical certificates, delay certificates from the SNCF, or others. Those justifications shall be delivered to the "sécretariat", not the instructor.

Delays. A student will be considered late if he/she enters the classroom up to 30 min after the stating time (usually 8.30am or 1.45pm). A delay will be considered unjustified unless the student provides appropriate justifying documents (see previous paragraph) or explanations to the instructor (not the "sécretariat"). Each student has the right to 1 unjustified delay per course (6 sessions = 3 days). Each unjustified delay starting from the 2nd will reduce 5% the overall course grade.

Being late for more than 30 min will be considered an absence for the entire session.

Grading. The final grade will be determined as follows:

Final course grade = Academic Grade * Attendance coef. * Delay coef.

Attendance coef.   = 1 - 0.5  * (Unjustified absences / Number of course sessions)
Delay coefficient  = 1 - 0.05 * (Unjustified delays - 1)

Academic grade     = 0.3 * Continuous assessment +
                     0.2 * Exercises
                     0.5 * Project

Collaboration. Discussion, exchange of ideas, and mutual help for understanding complex concepts are key aspects of the learning process inside of a classroom, and as such they are strongly encouraged in this course. However, any submitted piece of work (exercise solution, program code, report, etc.) displaying the student's name must be the result of the student's original and individual work. Helping your peer to independently reach the solution to a problem or difficulty is acceptable. Passing or receiving the solution from your peer is not.

Collaboration between students (working in groups of two or more) shall be explicitly authorised by the instructor.

All program code produced for the various course assignments is expected to be your own creation. Verbatim copying from Internet webpages or any other sources is entirely disallowed. Taking inspiration to write your own code from code in manpages, tutorials, etc. is allowed under the condition that the source is cited in comments.

Inside the classroom. Using mobile phones, music players, or headphones is disallowed inside of the classroom.

1.4   Evaluation of your code

Here are some criteria that will be taken into account for the evaluation of the source could that you are expected to submit in this course:

• Homogeneous and reasonable indentation and spacing (paragraphs, empty lines, spaces between words).
• Your code is as simple as possible, but not simpler.
• The code is clear, easy to read.
• Your code is robust and well tested. It rather displays error messages complaining about non-treated corner cases than it produces run-time crashes (for instance, segmentation faults).
• You use comments to explain your code. You are strongly advised to structure your code in paragraphs, and introduce every paragraph with a one-line comment. You can draw inspiration on every single code example you will see in this web page or the MSDN webpages.

1.5   Exercises and Project

• ThreadExercises.cs: Exercises 1 to 8 (threads)
• Client.cs, Server.cs: Exercises 9 to 12 (sockets)
• The project.

1.6   How to Submit Exercises / Code for Evaluation

You are expected to submit your source code using the ENT.

1. Last day. Exercises to be submitted until the last day of the course. Deadline: 11.55pm on January 11, 2017. Click here to submit. You are expected to submit exactly the following files:

   ThreadExercises.cs
   Client.cs
   Server.cs
   

   Please submit exactly those files. Do not change any file name. Do not add other files unless it is strictly necessary. Failure to follow these instructions will negatively impact your grade.

2. Programming project. The Survey system. Deadline: 11.55pm on TBD. Click here to submit.

2.1   Introduction

• What is a thread?
• Threads vs processes
• Preemtive multitasking, time slices
• When to use multiple threads?
  • Reactive user interaction when long calculations are needed
  • Communication
  • Priority

2.2   Delegates

Intuitively, a delegate is the type of a pointer to a function. A delegate also acts like a class. Each instance of the class is a pointer to a function of the right type (the type of the delegate). We can also "call" the instances, and that will indirectly call the function pointed.

Example:

class Test
{
   // the delegate
   private delegate int Comparer (object o1, object o2, int i);

   // a function with the same "type"
   private static int string_cmp (object ob1, object ob2, int i)
   {
     return i + ((string) ob1).Length - ((string) ob2).Length;
   }

   // another function with the same "type"
   private static int string_cmp (object ob1, object ob2, int i)
   {
       return 123;
   }

   static void Main ()
   {
     // cmp is an instance of the Comparer delegate; it points to string_cmp
     Comparer cmp = new Comparer (string_cmp);

     // you can "call" the variable cmp
     Console.WriteLine (cmp ("bye", "hello", 3));

     // will compile, but will throw an exception. Which?
     Console.WriteLine (cmp ("bye", 4.5f, 3));
   }
}

2.3   Creating a Thread, Minimal Example

• Threads are created via delegates, or parametrized delegates (so as to pass data to the thread)
• More examples at the Examples section from the class Thread.

using System;
using System.Threading;

class Example
{
   static void MyThread ()
   {
      for (int i = 0; i < 10; i++)
      {
         Console.WriteLine ("Thread: i = {0}", i);
         Thread.Sleep (200); // in ms
      }
   }

   static void Main (string [] args)
   {
      ThreadStart fun;
      Thread t;

      // we create an instance of the System.Threading.ThreadStart delegate,
      // then we create the thread
      fun = new ThreadStart (MyThread);
      t = new Thread (fun);

      // start the thread (this will not block the Main)
      t.Start();

      // do something on the main function
      for (int i = 0; i < 5; i++)
      {
         Console.WriteLine ("Main: i = {0}", i);
         Thread.Sleep (100);
      }

      // block until the thread terminates
      t.Join ();
      Console.WriteLine ("Main: end!");
   }
}

2.4   Passing data to the thread

There is two fundamental ways to pass data to the new thread:

1. Executing an instance method from a newly created object that contains the data. See 2nd example here.
2. Using the ParameterizedThreadStart delegate (observe that the Thread object has 4 constructors). In this case the function executed by the thread will have one argument.

Example of the first method:

class ThreadWithState {
   public int n;

   public ThreadWithState (int n_) {
      n = n_;
   }

   public void Work () {
      int orig = n;

      for (int i = 0; i < 2; i++)
         n *= orig;

      Console.WriteLine ("Thread: n = {0}, n^3 = {0}", orig, n);
   }
}

class Example2 {
   static void Main (string [] args) {
      ThreadWithState tws;
      Thread t;

      // we "pass" number 10 to the thread
      tws = new ThreadWithState (10);
      t = new Thread (new ThreadStart (tws.Work));

      t.Start ();
      t.Join ();

      // we "read" the results of the computation
      Console.WriteLine ("Main: tws.n = {0}", tws.n);
   }
}

Exercises: ThreadExercises.cs, exercises 1 and 2.

2.5   Thread Destruction

Calling method Thread.Abort causes the execption ThreadAbortException to be thrown in the thread. The thread can catch it. After the execution of the exeception handler, the thread cannot be restarted.

For more information, see Destroying threads.

2.6   Pausing and Resuming Threads

Calling method Thread.Interrupt will cause the execption ThreadInterruptedException to be thrown in the thread. The time at which the exception is thrown varies:

• If the thread is currently blocked on a blocking call (e.g., Thread.Sleep), it will be thrown immediately, and the blocking call will return immediately
• If the thread is currently running, it will be thrown the next time that the threads tries to call to a blocking function.

For more information, see Pausing and Resuming Threads.

The Thread class includes two methods, Thread.Suspend and Thread.Resume, for pausing and resuming a thread. However, the use of these methods is not recommended.

2.7   Other Generalities

• As a general overview, see the Managed Threading Basics section of the guide
• On single-processor machines, threads are executed during time slots of 20ms
• Executing Thread.Sleep (0) context-switches to a different executable thread and terminates the time slot given to this one
• Exceptions in thread generally terminate the process, with the exceptions mentioned here
• So do handle exceptions on threads, as they can have unexpected consequences if your threads synchronize in any way
• Foreground and background threads and the IsBackground property

2.8   Synchronization

When a program makes use of multiple threads, in almost all cases threads need to interact. Common interactions include to exchange data, to wait for each other when performing some task, to avoid modifying the same variables at the same time, to consume the data produced by another thread, etc.

Threads achieve these interactions using synchronization primitives, that is, low-level operations provided by the underlying programming language (C# in our case) to perform the elementary steps of an interaction between threads.

We already know at least two synchronization primitives: the methods Start and Join in the class Thread. The synchronization they produce (the constraints that they impose on the execution of the overall program) are as follows:

• The thread code will be executed only after the call to the Start method.
• The thread code will terminate always before the method Join returns.

These two obvious but important guarantees help the programmer to organize the interaction of the threads in order to achieve the goals of the application. In this section we will study the primitives that C# offers to write more complex thread interactions.

When thread interaction is not adequately performed, the application can display unexpected behavior and results. We shall start by studying a small program that illustrates what can go wrong when improper or no synchronization is used between threads:

class Bank {
   public int [] account;

   public Bank () {
      account = new int[4];
      for (int i = 0; i < 4; i++) account[i] = 100;
   }

   public void Transfer (int src, int dst, int quantity) {
      int balance;

      balance = account[src];
      Thread.Sleep (0);

      if (balance < quantity) {
         Console.WriteLine ("error: src {0} balance {1} quantity {2}",
            src, balance, quantity);
         return;
      }

      account[src] -= quantity;
      account[dst] += quantity;
   }

   public void Print () {
      for (int i = 0; i < 4; i++)
         Console.WriteLine ("account {0} balance {1}", i, account[i]);
   }

   public void Branch1 () {
      Transfer (0, 1, 50);
   }

   public void Branch2 () {
      Transfer (0, 2, 60);
   }
}

class Example3 {
   static void Main (string [] args) {
      Bank b = new Bank ();
      Thread t1 = new Thread (new ThreadStart (b.Branch1));
      Thread t2 = new Thread (new ThreadStart (b.Branch2));

      t1.Start ();
      t2.Start ();
      t1.Join ();
      t2.Join ();

      b.Print ();
   }
}

Pay close attention to the method Transfer. What can go wrong when two transfers are concurrently initiated from two different Bank branches (threads)?

A good conceptual overview of the synchronization primitives in C# can be found in the section Overview of Synchronization Primitives. We can divide all synchronization primitives that we will learn in this course in two classes:

• Locking: Locking primitives help your threads guaranteeing mutual exclusion. That is, only one thread (or a specific number of them) access one resource at a time.

  Locking primitives include the lock statement, Monitor, Mutex, SpinLock, ReaderWriterLock, Semaphore. Whenever possible the lock statement should be used.

• Signaling: Signaling consist on informing from one thread to one or more other threads of a specific condition.

  Signaling Primitives: EventWaitHandle and friends (auto reset, manual reset), Mutex, Semaphore, Barriers. All classes but Barrier derive from WaitHandle.

Exercises: ThreadExercises.cs, exercise 3.

System.Threading.Monitor.Enter (obj);
System.Threading.Monitor.Exit (obj);
System.Threading.Monitor.Wait (obj);
System.Threading.Monitor.Pulse (obj);

lock (obj)
{
   // the code here
}

System.Threading.Monitor.Enter (obj);
// the code here
System.Threading.Monitor.Exit (obj);

System.Threading.WaitHandle.WaitOne ()
System.Threading.WaitHandle.WaitAll (WaitHandle [])
System.Threading.WaitHandle.WaitAny (WaitHandle [])

bool           init = ?? // true or false
EventResetMode mode = ?? // EventResetMode.AutoReset or EventResetMode.ManualReset

h = new EventWaitHandle (init, mode);

CountdownEvent cde = new CountdownEvent (12)

2.9   The Thread Pool

• Interesting information in the Remarks section of the ThreadPool Class
• System.Threading.ThreadPool is static
• Threadpool.QueueUserWorkItem is the routine to execute start a thread
• You may pass an object to the function; the thread's function will receive it in its (single) argument (it will receive null if you did not provide an argument to QueueUserWorkItem)
• All threads are background threads

Exercises: ThreadExercises.cs, exercises 7 and 8.

2.10   Timers

See this article on the development guide.

3.1   Sockets

We focus on connective sockets, using TCP. The first step is creating the socket.

3.2   Above the Sockets interface: TCP and UDP Services

The classes TcpClient, TcpListener, and UdpClient help you opening data connections over TCP and UDP, as well as accepting incoming TCP connections. They abstract away the details of setting up and using sockets and provide a simplified access to the network.

Their use is straightforward, see

• Using TCP Services (for TcpClient and TcpListener), and
• Using UDP Services (for UdpClient).

Exercises: Client.cs, exercise 10.