Csharp/C Sharp/Thread/Thread Pool

illustrates the use of the system thread pool

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
  Example14_12.cs illustrates the use of the system thread pool
*/
using System;
using System.Threading;
public class Example14_12 
{
  // the Countdown method counts down from 1000 to 1
  public static void Countdown(Object o) 
  {
    for (int counter = 1000; counter > 0; counter--) 
    {
      Console.Write(counter.ToString() + " ");
    }
  }
  public static void Main() 
  {
    // ask the system to create and launch a second thread
    ThreadPool.QueueUserWorkItem(new WaitCallback(Countdown), null);
    // and meanwhile call the Countdown method from the first thread
    Countdown(null);
  }
}

Thread pool demo

/*
 * C# Programmers Pocket Consultant
 * Author: Gregory S. MacBeth
 * Email: gmacbeth@comporium.net
 * Create Date: June 27, 2003
 * Last Modified Date:
 * Version: 1
 */
using System;
using System.Threading;
namespace Client.Chapter_15___Threading
{
  public class MyMainClassChapter_15___Threading
  {
    public static ManualResetEvent MyManualEvent = new ManualResetEvent(false);
    public static AutoResetEvent MyAutoEvent = new AutoResetEvent(false);
    static void Main(string[] args)
    {
      ThreadPool.QueueUserWorkItem(new WaitCallback(DoBackgroundWorkManual));
      MyManualEvent.WaitOne();
      MyManualEvent.Reset();  //Sets the Event back to nonsignaled
      ThreadPool.QueueUserWorkItem(new WaitCallback(DoBackgroundWorkAuto));
      MyAutoEvent.WaitOne();
    }
    public static void DoBackgroundWorkManual(Object state)
    {
      Console.WriteLine("Thread 1");
      //Do stuff 
      //Then release control back to the main thread
      MyManualEvent.Set(); //Signals the event
    }
    public static void DoBackgroundWorkAuto(Object state)
    {
      Console.WriteLine("Thread 1");
      //Do stuff 
      MyAutoEvent.Set();
    }
  }
}

ThreadPool.QueueUserWorkItem

 

using System;
using System.Threading;

class WinterLocked {
    public ManualResetEvent a = new ManualResetEvent(false);
    private int i = 5;
    public void Run(object s) {
        Interlocked.Increment(ref i);
        Console.WriteLine("{0} {1}",
                          Thread.CurrentThread.GetHashCode(), i);
    }
}
public class MainApp {
    public static void Main() {
        ManualResetEvent mR = new ManualResetEvent(false);
        WinterLocked wL = new WinterLocked();
        for (int i = 1; i <= 10; i++) {
            ThreadPool.QueueUserWorkItem(new WaitCallback(wL.Run), 1);
        }
        mR.WaitOne(10000, true);
    }
}

ThreadPool.RegisterWaitForSingleObject

 
using System;
using System.Threading;
class MainClass
{
    private static void EventHandler(object state, bool timedout)
    {
        if (timedout)
        {
            Console.WriteLine("{0} : Wait timed out.", DateTime.Now.ToString("HH:mm:ss.ffff"));
        }
        else
        {
            Console.WriteLine("{0} : {1}", DateTime.Now.ToString("HH:mm:ss.ffff"), state);
        }
    }
    public static void Main()
    {
        AutoResetEvent autoEvent = new AutoResetEvent(false);
        string state = "AutoResetEvent signaled.";
        RegisteredWaitHandle handle = ThreadPool.RegisterWaitForSingleObject(autoEvent, EventHandler, state, 3000, false);
        while (Console.ReadLine().ToUpper() != "CANCEL")
        {
            autoEvent.Set();
        }
        Console.WriteLine("Unregistering wait operation.");
        handle.Unregister(null);
    }
}

Thread Pool Sample

-
using System;
using System.Threading;
public class ThreadPoolSample
{
   public static void Main()
   {
      ThreadPoolSample tps = new ThreadPoolSample();
   }
   public ThreadPoolSample()
   {
      int i;
      ThreadPool.QueueUserWorkItem(new WaitCallback(Counter));
      ThreadPool.QueueUserWorkItem(new WaitCallback(Counter2));
      for(i = 0; i < 10; i++)
      {
         Console.WriteLine("main: {0}", i);
         Thread.Sleep(1000);
      }
   }
   void Counter(object state)
   {
      int i;
      for (i = 0; i < 10; i++)
      {
         Console.WriteLine("  thread: {0}", i);
         Thread.Sleep(2000);
      }
   }
   void Counter2(object state)
   {
      int i;
      for (i = 0; i < 10; i++)
      {
         Console.WriteLine("    thread2: {0}", i);
         Thread.Sleep(3000);
      }
   }
}

Thread Pool Tcp Server

/*
C# Network Programming 
by Richard Blum
Publisher: Sybex 
ISBN: 0782141765
*/
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class ThreadPoolTcpSrvr
{
   private TcpListener client;
   public ThreadPoolTcpSrvr()
   {
      client = new TcpListener(9050);
      client.Start();
      Console.WriteLine("Waiting for clients...");
      while(true)
      {
         while (!client.Pending())
         {
            Thread.Sleep(1000);
         }
         ConnectionThread newconnection = new ConnectionThread();
         newconnection.threadListener = this.client;
         ThreadPool.QueueUserWorkItem(new
                    WaitCallback(newconnection.HandleConnection));
      }
   }
   public static void Main()
   {
      ThreadPoolTcpSrvr tpts = new ThreadPoolTcpSrvr();
   }
}
class ConnectionThread
{
   public TcpListener threadListener;
   private static int connections = 0;
   public void HandleConnection(object state)
   {
      int recv;
      byte[] data = new byte[1024];
      TcpClient client = threadListener.AcceptTcpClient();
      NetworkStream ns = client.GetStream();
      connections++;
      Console.WriteLine("New client accepted: {0} active connections",
                         connections);
      string welcome = "Welcome to my test server";
      data = Encoding.ASCII.GetBytes(welcome);
      ns.Write(data, 0, data.Length);
      while(true)
      {
         data = new byte[1024];
         recv = ns.Read(data, 0, data.Length);
         if (recv == 0)
            break;
      
         ns.Write(data, 0, recv);
      }
      ns.Close();
      client.Close();
      connections--;
      Console.WriteLine("Client disconnected: {0} active connections",
                         connections);
   }
}