C# 多线程

 1         static void Main(string[] args)
 2         {
 3             Thread thread = Thread.CurrentThread;
 4             thread.Name = "Main Thread";
 5             string threadMessage = string.Format("Thread ID:{0}\n    Current AppDomainId:{1}\n    "+
 6                 "Current ContextId:{2}\n    Thread Name:{3}\n    "+
 7                 "Thread State:{4}\n    Thread Priority:{5}\n",
 8                 thread.ManagedThreadId, Thread.GetDomainID(), Thread.CurrentContext.ContextID,
 9                 thread.Name, thread.ThreadState, thread.Priority);
10             Console.WriteLine(threadMessage);
11             Console.ReadKey();
12         }

 1       public class Message
 2       {
 3           public void ShowMessage()
 4           {
 5               string message = string.Format("Async threadId is :{0}",
 6                                               Thread.CurrentThread.ManagedThreadId);
 7               Console.WriteLine(message);
 8   
 9               for (int n = 0; n < 10; n++)
10               {
11                   Thread.Sleep(300);   
12                   Console.WriteLine("The number is:" + n.ToString()); 
13               }
14           }
15       }
16   
17       class Program
18       {
19           static void Main(string[] args)
20           {
21               Console.WriteLine("Main threadId is:"+
22                                 Thread.CurrentThread.ManagedThreadId);
23               Message message=new Message();
24               Thread thread = new Thread(new ThreadStart(message.ShowMessage));
25               thread.Start();
26               Console.WriteLine("Do something ..........!");
27               Console.WriteLine("Main thread working is complete!");
28               
29           }
30       }

 1     public class Person
 2     {
 3         public string Name
 4         {
 5             get;
 6             set;
 7         }
 8         public int Age
 9         {
10             get;
11             set;
12         }
13     }
14 
15     public class Message
16     {
17         public void ShowMessage(object person)
18         {
19             if (person != null)
20             {
21                 Person _person = (Person)person;
22                 string message = string.Format("\n{0}‘s age is {1}!\nAsync threadId is:{2}",
23                     _person.Name,_person.Age,Thread.CurrentThread.ManagedThreadId);
24                 Console.WriteLine(message);
25             }
26             for (int n = 0; n < 10; n++)
27             {
28                 Thread.Sleep(300);   
29                 Console.WriteLine("The number is:" + n.ToString()); 
30             }
31         }
32     }
33 
34     class Program
35     {
36         static void Main(string[] args)
37         {     
38             Console.WriteLine("Main threadId is:"+Thread.CurrentThread.ManagedThreadId);
39             
40             Message message=new Message();
41             //绑定带参数的异步方法
42             Thread thread = new Thread(new ParameterizedThreadStart(message.ShowMessage));
43             Person person = new Person();
44             person.Name = "Jack";
45             person.Age = 21;
46             thread.Start(person);  //启动异步线程 
47             
48             Console.WriteLine("Do something ..........!");
49             Console.WriteLine("Main thread working is complete!");
50              
51         }
52     }

 1     public class Message
 2     {
 3         public void ShowMessage()
 4         {
 5             string message = string.Format("\nAsync threadId is:{0}",
 6                                            Thread.CurrentThread.ManagedThreadId);
 7             Console.WriteLine(message);
 8             for (int n = 0; n < 10; n++)
 9             {
10                 Thread.Sleep(300);
11                 Console.WriteLine("The number is:" + n.ToString());
12             }
13         }
14     }
15 
16     class Program
17     {
18         static void Main(string[] args)
19         {     
20             Console.WriteLine("Main threadId is:"+
21                               Thread.CurrentThread.ManagedThreadId);
22             
23             Message message=new Message();
24             Thread thread = new Thread(new ThreadStart(message.ShowMessage));
25             thread.IsBackground = true;
26             thread.Start();
27             
28             Console.WriteLine("Do something ..........!");
29             Console.WriteLine("Main thread working is complete!");
30             Console.WriteLine("Main thread sleep!");
31             Thread.Sleep(5000);
32         }
33     }

 1          static void Main(string[] args)
 2          {
 3              Console.WriteLine("Main threadId is:" +
 4                                Thread.CurrentThread.ManagedThreadId);
 5  
 6              Thread thread = new Thread(new ThreadStart(AsyncThread));
 7              thread.IsBackground = true;
 8              thread.Start();
 9              thread.Join();
10  
11          }     
12          
13          //以异步方式调用
14          static void AsyncThread()
15          {
16              try
17              {
18                  string message = string.Format("\nAsync threadId is:{0}",
19                     Thread.CurrentThread.ManagedThreadId);
20                  Console.WriteLine(message);
21  
22                  for (int n = 0; n < 10; n++)
23                  {
24                      //当n等于4时，终止线程
25                      if (n >= 4)
26                      {
27                          Thread.CurrentThread.Abort(n);
28                      }
29                      Thread.Sleep(300);
30                      Console.WriteLine("The number is:" + n.ToString());
31                  }
32              }
33              catch (ThreadAbortException ex)
34              {
35                  //输出终止线程时n的值
36                  if (ex.ExceptionState != null)
37                      Console.WriteLine(string.Format("Thread abort when the number is: {0}!", 
38                                                       ex.ExceptionState.ToString()));
39                 
40                  //取消终止，继续执行线程
41                  Thread.ResetAbort();
42                  Console.WriteLine("Thread ResetAbort!");
43              }
44  
45              //线程结束
46              Console.WriteLine("Thread Close!");
47          }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //把CLR线程池的最大值设置为1000
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7             //显示主线程启动时线程池信息
 8             ThreadMessage("Start");
 9             //启动工作者线程
10             ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback));
11             Console.ReadKey();
12         }
13         
14         static void AsyncCallback(object state)
15         {
16             Thread.Sleep(200);
17             ThreadMessage("AsyncCallback");
18             Console.WriteLine("Async thread do work!");
19         }
20 
21         //显示线程现状
22         static void ThreadMessage(string data)
23         {
24             string message = string.Format("{0}\n  CurrentThreadId is {1}",
25                  data, Thread.CurrentThread.ManagedThreadId);
26             Console.WriteLine(message);
27         }
28     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //把线程池的最大值设置为1000
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7           
 8             ThreadMessage("Start");
 9             ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback),"Hello Elva");
10             Console.ReadKey();
11         }
12 
13         static void AsyncCallback(object state)
14         {
15             Thread.Sleep(200);
16             ThreadMessage("AsyncCallback");
17 
18             string data = (string)state;
19             Console.WriteLine("Async thread do work!\n"+data);
20         }
21 
22         //显示线程现状
23         static void ThreadMessage(string data)
24         {
25             string message = string.Format("{0}\n  CurrentThreadId is {1}",
26                  data, Thread.CurrentThread.ManagedThreadId);
27             Console.WriteLine(message);
28         }
29     }

 1     class Program
 2     {
 3         delegate void MyDelegate();
 4 
 5         static void Main(string[] args)
 6         {
 7             MyDelegate delegate1 = new MyDelegate(AsyncThread);
 8             //显示委托类的几个方法成员     
 9             var methods=delegate1.GetType().GetMethods();
10             if (methods != null)
11                 foreach (MethodInfo info in methods)
12                     Console.WriteLine(info.Name);
13             Console.ReadKey();
14          }
15      }

1     public class MyDelegate:MulticastDelegate
2     {
3         public MyDelegate(object target, int methodPtr);
4         //调用委托方法
5         public virtual void Invoke();
6         //异步委托
7         public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
8         public virtual void EndInvoke(IAsyncResult result);
9     }

 1     class Program
 2     {
 3         delegate string MyDelegate(string name);
 4 
 5         static void Main(string[] args)
 6         {
 7             ThreadMessage("Main Thread");
 8             
 9             //建立委托
10             MyDelegate myDelegate = new MyDelegate(Hello);
11             //异步调用委托，获取计算结果
12             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
13             //完成主线程其他工作
14             ............. 
15             //等待异步方法完成，调用EndInvoke(IAsyncResult)获取运行结果
16             string data=myDelegate.EndInvoke(result);
17             Console.WriteLine(data);
18             
19             Console.ReadKey();
20         }
21 
22         static string Hello(string name)
23         {
24             ThreadMessage("Async Thread");
25             Thread.Sleep(2000);            //虚拟异步工作
26             return "Hello " + name;
27         }
28 
29         //显示当前线程
30         static void ThreadMessage(string data)
31         {
32             string message = string.Format("{0}\n  ThreadId is:{1}",
33                    data,Thread.CurrentThread.ManagedThreadId);
34             Console.WriteLine(message);
35         }
36     }

1 public interface IAsyncResult
2 {
3     object AsyncState {get;}            //获取用户定义的对象，它限定或包含关于异步操作的信息。
4     WailHandle AsyncWaitHandle {get;}   //获取用于等待异步操作完成的 WaitHandle。
5     bool CompletedSynchronously {get;}  //获取异步操作是否同步完成的指示。
6     bool IsCompleted {get;}             //获取异步操作是否已完成的指示。
7 }

 1     class Program
 2     {
 3         delegate string MyDelegate(string name);
 4 
 5         static void Main(string[] args)
 6         {
 7             ThreadMessage("Main Thread");
 8             
 9             //建立委托
10             MyDelegate myDelegate = new MyDelegate(Hello);
11             //异步调用委托，获取计算结果
12             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
13             //在异步线程未完成前执行其他工作
14             while (!result.IsCompleted)
15             {
16                 Thread.Sleep(200);      //虚拟操作
17                 Console.WriteLine("Main thead do work!");
18             }
19             string data=myDelegate.EndInvoke(result);
20             Console.WriteLine(data);
21             
22             Console.ReadKey();
23         }
24 
25         static string Hello(string name)
26         {
27             ThreadMessage("Async Thread");
28             Thread.Sleep(2000);
29             return "Hello " + name;
30         }
31 
32         static void ThreadMessage(string data)
33         {
34             string message = string.Format("{0}\n  ThreadId is:{1}",
35                    data,Thread.CurrentThread.ManagedThreadId);
36             Console.WriteLine(message);
37         }
38     }

 1 namespace Test
 2 {
 3     class Program
 4     {
 5         delegate string MyDelegate(string name);
 6 
 7         static void Main(string[] args)
 8         {
 9             ThreadMessage("Main Thread");
10             
11             //建立委托
12             MyDelegate myDelegate = new MyDelegate(Hello);
13  
14             //异步调用委托，获取计算结果
15             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
16             
17             while (!result.AsyncWaitHandle.WaitOne(200))
18             {
19                 Console.WriteLine("Main thead do work!");
20             }
21             string data=myDelegate.EndInvoke(result);
22             Console.WriteLine(data);
23             
24             Console.ReadKey();
25         }
26 
27         static string Hello(string name)
28         {
29             ThreadMessage("Async Thread");
30             Thread.Sleep(2000);
31             return "Hello " + name;
32         }
33 
34         static void ThreadMessage(string data)
35         {
36             string message = string.Format("{0}\n  ThreadId is:{1}",
37                    data,Thread.CurrentThread.ManagedThreadId);
38             Console.WriteLine(message);
39         }
40     }

 1     class Program
 2     {
 3         delegate string MyDelegate(string name);
 4 
 5         static void Main(string[] args)
 6         {
 7             ThreadMessage("Main Thread");
 8             
 9             //建立委托
10             MyDelegate myDelegate = new MyDelegate(Hello);
11  
12             //异步调用委托，获取计算结果
13             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
14 
15             //此处可加入多个检测对象
16             WaitHandle[] waitHandleList = new WaitHandle[] { result.AsyncWaitHandle,........ };
17             while (!WaitHandle.WaitAll(waitHandleList,200))
18             {
19                 Console.WriteLine("Main thead do work!");
20             }
21             string data=myDelegate.EndInvoke(result);
22             Console.WriteLine(data);
23             
24             Console.ReadKey();
25         }
26 
27         static string Hello(string name)
28         {
29             ThreadMessage("Async Thread");
30             Thread.Sleep(2000);
31             return "Hello " + name;
32         }
33 
34         static void ThreadMessage(string data)
35         {
36             string message = string.Format("{0}\n  ThreadId is:{1}",
37                    data,Thread.CurrentThread.ManagedThreadId);
38             Console.WriteLine(message);
39         }
40     }

 1     class Program
 2     {
 3         delegate string MyDelegate(string name);
 4 
 5         static void Main(string[] args)
 6         {
 7             ThreadMessage("Main Thread");
 8 
 9             //建立委托
10             MyDelegate myDelegate = new MyDelegate(Hello);
11             //异步调用委托，获取计算结果
12             myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
13             //在启动异步线程后，主线程可以继续工作而不需要等待
14             for (int n = 0; n < 6; n++)
15                 Console.WriteLine("  Main thread do work!");
16             Console.WriteLine("");
17 
18             Console.ReadKey();
19         }
20 
21         static string Hello(string name)
22         {
23             ThreadMessage("Async Thread");
24             Thread.Sleep(2000);             \\模拟异步操作
25             return "\nHello " + name;
26         }
27 
28         static void Completed(IAsyncResult result)
29         {
30             ThreadMessage("Async Completed");
31 
32             //获取委托对象，调用EndInvoke方法获取运行结果
33             AsyncResult _result = (AsyncResult)result;
34             MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
35             string data = myDelegate.EndInvoke(_result);
36             Console.WriteLine(data);
37         }
38 
39         static void ThreadMessage(string data)
40         {
41             string message = string.Format("{0}\n  ThreadId is:{1}",
42                    data, Thread.CurrentThread.ManagedThreadId);
43             Console.WriteLine(message);
44         }
45     }

 1     class Program
 2     {
 3         public class Person
 4         {
 5             public string Name;
 6             public int Age;
 7         }
 8 
 9         delegate string MyDelegate(string name);
10 
11         static void Main(string[] args)
12         {
13             ThreadMessage("Main Thread");
14 
15             //建立委托
16             MyDelegate myDelegate = new MyDelegate(Hello);
17             
18             //建立Person对象
19             Person person = new Person();
20             person.Name = "Elva";
21             person.Age = 27;
22             
23             //异步调用委托，输入参数对象person, 获取计算结果
24             myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);            
25           
26             //在启动异步线程后，主线程可以继续工作而不需要等待
27             for (int n = 0; n < 6; n++)
28                 Console.WriteLine("  Main thread do work!");
29             Console.WriteLine("");
30 
31             Console.ReadKey();
32         }
33 
34         static string Hello(string name)
35         {
36             ThreadMessage("Async Thread");
37             Thread.Sleep(2000);
38             return "\nHello " + name;
39         }
40 
41         static void Completed(IAsyncResult result)
42         {
43             ThreadMessage("Async Completed");
44 
45             //获取委托对象，调用EndInvoke方法获取运行结果
46             AsyncResult _result = (AsyncResult)result;
47             MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
48             string data = myDelegate.EndInvoke(_result);
49             //获取Person对象
50             Person person = (Person)result.AsyncState;
51             string message = person.Name + "‘s age is " + person.Age.ToString();
52 
53             Console.WriteLine(data+"\n"+message);
54         }
55 
56         static void ThreadMessage(string data)
57         {
58             string message = string.Format("{0}\n  ThreadId is:{1}",
59                    data, Thread.CurrentThread.ManagedThreadId);
60             Console.WriteLine(message);
61         }
62     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //把线程池的最大值设置为1000
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7             ThreadPoolMessage("Start");
 8 
 9             //新立文件File.sour
10             FileStream stream = new FileStream("File.sour", FileMode.OpenOrCreate, 
11                                        FileAccess.ReadWrite,FileShare.ReadWrite,1024,true);
12             byte[] bytes = new byte[16384];
13             string message = "An operating-system ThreadId has no fixed relationship........";
14             bytes = Encoding.Unicode.GetBytes(message);
15 
16             //启动异步写入
17             stream.BeginWrite(bytes, 0, (int)bytes.Length,new AsyncCallback(Callback),stream);
18             stream.Flush();
19             
20             Console.ReadKey();
21         }
22 
23         static void Callback(IAsyncResult result)
24         {
25             //显示线程池现状
26             Thread.Sleep(200);
27             ThreadPoolMessage("AsyncCallback");
28             //结束异步写入
29             FileStream stream = (FileStream)result.AsyncState;
30             stream.EndWrite(result);
31             stream.Close();
32         }
33 
34         //显示线程池现状
35         static void ThreadPoolMessage(string data)
36         {
37             int a, b;
38             ThreadPool.GetAvailableThreads(out a, out b);
39             string message = string.Format("{0}\n  CurrentThreadId is {1}\n  "+
40                   "WorkerThreads is:{2}  CompletionPortThreads is :{3}",
41                   data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
42             Console.WriteLine(message);
43         }
44     }

 1      class Program
 2      {
 3          public class FileData
 4          {
 5              public FileStream Stream;
 6              public int Length;
 7              public byte[] ByteData;
 8          }
 9  
10          static void Main(string[] args)
11          {       
12              //把线程池的最大值设置为1000
13              ThreadPool.SetMaxThreads(1000, 1000);
14              ThreadPoolMessage("Start");
15              ReadFile();
16  
17              Console.ReadKey();
18          }
19  
20          static void ReadFile()
21          {
22              byte[] byteData=new byte[80961024];
23              FileStream stream = new FileStream("File1.sour", FileMode.OpenOrCreate, 
24                                      FileAccess.ReadWrite, FileShare.ReadWrite, 1024, true);
25              
26              //把FileStream对象,byte[]对象，长度等有关数据绑定到FileData对象中，以附带属性方式送到回调函数
27              FileData fileData = new FileData();
28              fileData.Stream = stream;
29              fileData.Length = (int)stream.Length;
30              fileData.ByteData = byteData;
31              
32              //启动异步读取
33              stream.BeginRead(byteData, 0, fileData.Length, new AsyncCallback(Completed), fileData);
34          }
35   
36          static void Completed(IAsyncResult result)
37          {
38              ThreadPoolMessage("Completed");
39  
40              //把AsyncResult.AsyncState转换为FileData对象，以FileStream.EndRead完成异步读取
41              FileData fileData = (FileData)result.AsyncState;
42              int length=fileData.Stream.EndRead(result);
43              fileData.Stream.Close();
44  
45              //如果读取到的长度与输入长度不一致，则抛出异常
46              if (length != fileData.Length)
47                  throw new Exception("Stream is not complete!");
48  
49              string data=Encoding.ASCII.GetString(fileData.ByteData, 0, fileData.Length);
50              Console.WriteLine(data.Substring(2,22));
51          }
52  
53          //显示线程池现状
54          static void ThreadPoolMessage(string data)
55          {
56              int a, b;
57              ThreadPool.GetAvailableThreads(out a, out b);
58              string message = string.Format("{0}\n  CurrentThreadId is {1}\n  "+
59                           "WorkerThreads is:{2}  CompletionPortThreads is :{3}",
60                           data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
61              Console.WriteLine(message);      
62          }
63              
64    }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //设置CLR线程池最大线程数
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7    
 8             //默认地址为127.0.0.1
 9             IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
10             TcpListener tcpListener = new TcpListener(ipAddress, 500);
11             tcpListener.Start();
12             
13             //以一个死循环来实现监听
14             while (true)
15             {   //调用一个ChatClient对象来实现监听
16                 ChatClient chatClient = new ChatClient(tcpListener.AcceptTcpClient());    
17             }
18         }
19     }
20 
21     public class ChatClient
22     {
23         static TcpClient tcpClient;
24         static byte[] byteMessage;
25         static string clientEndPoint;
26 
27         public ChatClient(TcpClient tcpClient1)
28         {
29             tcpClient = tcpClient1;
30             byteMessage = new byte[tcpClient.ReceiveBufferSize];
31            
32             //显示客户端信息
33             clientEndPoint = tcpClient.Client.RemoteEndPoint.ToString();
34             Console.WriteLine("Client‘s endpoint is " + clientEndPoint);
35             
36             //使用NetworkStream.BeginRead异步读取信息
37             NetworkStream networkStream = tcpClient.GetStream();
38             networkStream.BeginRead(byteMessage, 0, tcpClient.ReceiveBufferSize,
39                                          new AsyncCallback(ReceiveAsyncCallback), null);
40         }
41 
42         public void ReceiveAsyncCallback(IAsyncResult iAsyncResult)
43         {
44             //显示CLR线程池状态
45             Thread.Sleep(100);
46             ThreadPoolMessage("\nMessage is receiving");
47 
48             //使用NetworkStream.EndRead结束异步读取
49             NetworkStream networkStreamRead = tcpClient.GetStream();
50             int length=networkStreamRead.EndRead(iAsyncResult);
51 
52             //如果接收到的数据长度少于1则抛出异常
53             if (length < 1)
54             {
55                 tcpClient.GetStream().Close();
56                 throw new Exception("Disconnection!");
57             }
58 
59             //显示接收信息
60             string message = Encoding.UTF8.GetString(byteMessage, 0, length);
61             Console.WriteLine("Message:" + message);
62 
63             //使用NetworkStream.BeginWrite异步发送信息
64             byte[] sendMessage = Encoding.UTF8.GetBytes("Message is received!");
65             NetworkStream networkStreamWrite=tcpClient.GetStream();
66             networkStreamWrite.BeginWrite(sendMessage, 0, sendMessage.Length, 
67                                             new AsyncCallback(SendAsyncCallback), null);
68         }
69 
70         //把信息转换成二进制数据，然后发送到客户端
71         public void SendAsyncCallback(IAsyncResult iAsyncResult)
72         {
73             //显示CLR线程池状态
74             Thread.Sleep(100);
75             ThreadPoolMessage("\nMessage is sending");
76 
77             //使用NetworkStream.EndWrite结束异步发送
78             tcpClient.GetStream().EndWrite(iAsyncResult);
79 
80             //重新监听
81             tcpClient.GetStream().BeginRead(byteMessage, 0, tcpClient.ReceiveBufferSize,
82                                                new AsyncCallback(ReceiveAsyncCallback), null);
83         }
84 
85         //显示线程池现状
86         static void ThreadPoolMessage(string data)
87         {
88             int a, b;
89             ThreadPool.GetAvailableThreads(out a, out b);
90             string message = string.Format("{0}\n  CurrentThreadId is {1}\n  " +
91                   "WorkerThreads is:{2}  CompletionPortThreads is :{3}\n",
92                   data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
93 
94             Console.WriteLine(message);
95         }
96     }

 1         static void Main(string[] args)
 2         {
 3             //连接服务端
 4             TcpClient tcpClient = new TcpClient("127.0.0.1", 500);
 5 
 6             //发送信息
 7             NetworkStream networkStream = tcpClient.GetStream();
 8             byte[] sendMessage = Encoding.UTF8.GetBytes("Client request connection!");
 9             networkStream.Write(sendMessage, 0, sendMessage.Length);
10             networkStream.Flush();
11 
12             //接收信息
13             byte[] receiveMessage=new byte[1024];
14             int count=networkStream.Read(receiveMessage, 0,1024);
15             Console.WriteLine(Encoding.UTF8.GetString(receiveMessage));
16             Console.ReadKey();
17         }

 1 namespace Model
 2 {
 3     [Serializable]
 4     public class Person
 5     {
 6         public int ID
 7         {
 8             get;
 9             set;
10         }
11         public string Name
12         {
13             get;
14             set;
15         }
16         public int Age
17         {
18             get;
19             set;
20         }
21     }
22 }

 1 public class Handler : IHttpHandler {
 2 
 3     public void ProcessRequest(HttpContext context)
 4     {
 5         //把信息转换为String，找出输入条件Id
 6         byte[] bytes=new byte[1024];
 7         int length=context.Request.InputStream.Read(bytes,0,1024);
 8         string condition = Encoding.Default.GetString(bytes);
 9         int id = int.Parse(condition.Split(new string[] { ":" }, 
10                            StringSplitOptions.RemoveEmptyEntries)[1]);
11         
12         //根据Id查找对应Person对象
13         var person = GetPersonList().Where(x => x.ID == id).First();
14         
15         //所Person格式化为二进制数据写入OutputStream
16         BinaryFormatter formatter = new BinaryFormatter();
17         formatter.Serialize(context.Response.OutputStream, person);
18     }
19 
20     //模拟源数据
21     private IList<Person> GetPersonList()
22     {
23         var personList = new List<Person>();
24         
25         var person1 = new Person();
26         person1.ID = 1;
27         person1.Name = "Leslie";
28         person1.Age = 30;
29         personList.Add(person1);
30         ...........
31         return personList;
32     }
33 
34     public bool IsReusable
35     {
36         get { return true;}
37     }
38 }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             ThreadPool.SetMaxThreads(1000, 1000);
 6             Request();
 7             Console.ReadKey();
 8         }
 9 
10         static void Request()
11         {
12             ThreadPoolMessage("Start"); 
13             //使用WebRequest.Create方法建立HttpWebRequest对象
14             HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(
15                                             "http://localhost:5700/Handler.ashx");
16             webRequest.Method = "post";
17            
18             //对写入数据的RequestStream对象进行异步请求
19             IAsyncResult result=webRequest.BeginGetRequestStream(
20                 new AsyncCallback(EndGetRequestStream),webRequest);
21         }
22 
23         static void EndGetRequestStream(IAsyncResult result)
24         {
25             ThreadPoolMessage("RequestStream Complete");
26             //获取RequestStream
27             HttpWebRequest webRequest = (HttpWebRequest)result.AsyncState;
28             Stream stream=webRequest.EndGetRequestStream(result);
29 
30             //写入请求条件
31             byte[] condition = Encoding.Default.GetBytes("Id:1");
32             stream.Write(condition, 0, condition.Length);
33 
34             //异步接收回传信息
35             IAsyncResult responseResult = webRequest.BeginGetResponse(
36                 new AsyncCallback(EndGetResponse), webRequest);
37         }
38 
39         static void EndGetResponse(IAsyncResult result)
40         {
41             //显出线程池现状
42             ThreadPoolMessage("GetResponse Complete");
43 
44             //结束异步请求，获取结果
45             HttpWebRequest webRequest = (HttpWebRequest)result.AsyncState;
46             WebResponse webResponse = webRequest.EndGetResponse(result);
47             
48             //把输出结果转化为Person对象
49             Stream stream = webResponse.GetResponseStream();
50             BinaryFormatter formatter = new BinaryFormatter();
51             var person=(Person)formatter.Deserialize(stream);
52             Console.WriteLine(string.Format("Person    Id:{0} Name:{1} Age:{2}",
53                 person.ID, person.Name, person.Age));
54         }
55 
56         //显示线程池现状
57         static void ThreadPoolMessage(string data)
58         {
59             int a, b;
60             ThreadPool.GetAvailableThreads(out a, out b);
61             string message = string.Format("{0}\n  CurrentThreadId is {1}\n  " +
62                   "WorkerThreads is:{2}  CompletionPortThreads is :{3}\n",
63                   data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
64 
65             Console.WriteLine(message);
66         }
67     }

 1      [ServiceContract]
 2      public interface IExampleService
 3      {
 4          [OperationContract]
 5          string Method(string name);
 6      }
 7  
 8      public class ExampleService : IExampleService
 9      {
10          public string Method(string name)
11          {
12              return "Hello " + name;
13          }
14      }
15  
16      class Program
17      {
18          static void Main(string[] args)
19          {
20              ServiceHost host = new ServiceHost(typeof(ExampleService));
21              host.Open();
22              Console.ReadKey();
23              host.Close();
24           }
25      }
26  
27  <configuration>
28      <system.serviceModel>
29          <services>
30              <service name="Example.ExampleService">
31                  <endpoint address="" binding="wsHttpBinding" contract="Example.IExampleService">
32                      <identity>
33                          <dns value="localhost" />
34                      </identity>
35                  </endpoint>
36                  <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
37                  <host>
38                      <baseAddresses>
39                          <add baseAddress="http://localhost:7200/Example/ExampleService/" />
40                      </baseAddresses>
41                  </host>
42              </service>
43          </services>
44      </system.serviceModel>
45  </configuration>

 1      class Program
 2      {
 3          static void Main(string[] args)
 4          {
 5              //设置最大线程数
 6              ThreadPool.SetMaxThreads(1000, 1000);
 7              ThreadPoolMessage("Start");
 8              
 9              //建立服务对象，异步调用服务方法
10              ExampleServiceReference.ExampleServiceClient exampleService = new
11                                      ExampleServiceReference.ExampleServiceClient();
12              exampleService.BeginMethod("Leslie",new AsyncCallback(AsyncCallbackMethod), 
13                                          exampleService);  
14              Console.ReadKey();
15          }
16  
17          static void AsyncCallbackMethod(IAsyncResult result)
18          {
19              Thread.Sleep(1000);
20              ThreadPoolMessage("Complete");
21              ExampleServiceReference.ExampleServiceClient example =
22                  (ExampleServiceReference.ExampleServiceClient)result.AsyncState;
23              string data=example.EndMethod(result);
24              Console.WriteLine(data);
25          }
26  
27          //显示线程池现状
28          static void ThreadPoolMessage(string data)
29          {
30              int a, b;
31              ThreadPool.GetAvailableThreads(out a, out b);
32              string message = string.Format("{0}\n  CurrentThreadId is {1}\n  " +
33                    "WorkerThreads is:{2}  CompletionPortThreads is :{3}\n",
34                    data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
35  
36              Console.WriteLine(message);
37          }
38      }
39  
40  <configuration>
41      <system.serviceModel>
42          <bindings>
43              <wsHttpBinding>
44                  <binding name="WSHttpBinding_IExampleService" closeTimeout="00:01:00"
45                      openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
46                      bypassProxyOnLocal="false" transactionFlow="false" 
47                      hostNameComparisonMode="StrongWildcard" maxBufferPoolSize="524288"
48                      maxReceivedMessageSize="65536" messageEncoding="Text" textEncoding="utf-8"
49                      useDefaultWebProxy="true" allowCookies="false">
50                      <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
51                          maxBytesPerRead="4096" maxNameTableCharCount="16384" />
52                      <reliableSession ordered="true" inactivityTimeout="00:10:00" enabled="false" />
53                      <security mode="Message">
54                          <transport clientCredentialType="Windows" proxyCredentialType="None"
55                            realm="" />
56                          <message clientCredentialType="Windows" negotiateServiceCredential="true"
57                              algorithmSuite="Default" />
58                      </security>
59                  </binding>
60              </wsHttpBinding>
61          </bindings>
62          <client>
63              <endpoint address="http://localhost:7200/Example/ExampleService/"
64                  binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_IExampleService"
65                  contract="ExampleServiceReference.IExampleService" 
66                  name="WSHttpBinding_IExampleService">
67                  <identity>
68                      <dns value="localhost" />
69                  </identity>
70              </endpoint>
71          </client>
72      </system.serviceModel>
73  </configuration>

 1     class Program
 2     {
 3         //把Asynchronous Processing设置为true
 4         static string connectionString = "Data Source=LESLIE-PC;Initial Catalog=Business;“+
 5                                          "Integrated Security=True;Asynchronous Processing=true";
 6 
 7         static void Main(string[] args)
 8         {
 9             //把CLR线程池最大线程数设置为1000
10             ThreadPool.SetMaxThreads(1000, 1000);
11             ThreadPoolMessage("Start");
12 
13             //使用WAITFOR DELAY命令来虚拟操作
14             SqlConnection connection = new SqlConnection(connectionString);
15             SqlCommand command = new SqlCommand("WAITFOR DELAY ‘0:0:3‘;", connection);
16             connection.Open();
17 
18             //启动异步SqlCommand操作，利用轮询方式监测操作
19             IAsyncResult result = command.BeginExecuteNonQuery();
20             ThreadPoolMessage("BeginRead");
21             while (!result.AsyncWaitHandle.WaitOne(500))
22                 Console.WriteLine("Main thread do work........");
23 
24             //结束异步SqlCommand
25             int count= command.EndExecuteNonQuery(result);
26             ThreadPoolMessage("\nCompleted");
27             Console.ReadKey();
28         }
29 
30         //显示线程池现状
31         static void ThreadPoolMessage(string data)
32         {
33             int a, b;
34             ThreadPool.GetAvailableThreads(out a, out b);
35             string message = string.Format("{0}\n  CurrentThreadId is {1}\n  "+
36                    "WorkerThreads is:{2}  CompletionPortThreads is :{3}\n",
37                    data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
38             Console.WriteLine(message);
39         }
40     }

 1     class Program
 2     {
 3         //把Asynchronous Processing设置为true
 4         static string connectionString = "Data Source=LESLIE-PC;Initial Catalog=Business;”+
 5                                          “Integrated Security=True;Asynchronous Processing=true";
 6         static void Main(string[] args)
 7         {
 8             //把CLR线程池最大线程数设置为1000
 9             ThreadPool.SetMaxThreads(1000, 1000);
10             ThreadPoolMessage("Start");
11 
12             //使用WAITFOR DELAY命令来虚拟操作
13             SqlConnection connection = new SqlConnection(connectionString);
14             SqlCommand command = new SqlCommand("WAITFOR DELAY ‘0:0:3‘;", connection);
15             connection.Open();
16             
17             //启动异步SqlCommand操作，并把SqlCommand对象传递到回调函数
18             IAsyncResult result = command.BeginExecuteNonQuery(
19                                        new AsyncCallback(AsyncCallbackMethod),command);
20             Console.ReadKey();
21         }
22 
23         static void AsyncCallbackMethod(IAsyncResult result)
24         {
25             Thread.Sleep(200);
26             ThreadPoolMessage("AsyncCallback");
27             SqlCommand command = (SqlCommand)result.AsyncState;
28             int count=command.EndExecuteNonQuery(result);
29             command.Connection.Close();
30         }
31 
32         //显示线程池现状
33         static void ThreadPoolMessage(string data)
34         {
35             int a, b;
36             ThreadPool.GetAvailableThreads(out a, out b);
37             string message = string.Format("{0}\n  CurrentThreadId is {1}\n  "+
38                   "WorkerThreads is:{2}  CompletionPortThreads is :{3}\n",
39                   data, Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
40 
41             Console.WriteLine(message);
42         }
43     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //设置最大线程数
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7             //并行查询
 8             Parallel.For(0, 3,n =>
 9                 {
10                     Thread.Sleep(2000);  //模拟查询
11                     ThreadPoolMessage(GetPersonList()[n]);
12                 });
13             Console.ReadKey();
14         }
15 
16         //模拟源数据
17         static IList<Person> GetPersonList()
18         {
19             var personList = new List<Person>();
20 
21             var person1 = new Person();
22             person1.ID = 1;
23             person1.Name = "Leslie";
24             person1.Age = 30;
25             personList.Add(person1);
26             ...........
27             return personList;
28         }
29 
30         //显示线程池现状
31         static void ThreadPoolMessage(Person person)
32         {
33             int a, b;
34             ThreadPool.GetAvailableThreads(out a, out b);
35             string message = string.Format("Person  ID:{0} Name:{1} Age:{2}\n" +
36                   "  CurrentThreadId is {3}\n  WorkerThreads is:{4}" +
37                   "  CompletionPortThreads is :{5}\n",
38                   person.ID, person.Name, person.Age,
39                   Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
40 
41             Console.WriteLine(message);
42         }
43     }

 1     class Program
 2     {
 3          static void Main(string[] args)
 4          {
 5              //设置最大线程数
 6              ThreadPool.SetMaxThreads(1000, 1000);
 7  
 8              //并行查询
 9              Parallel.ForEach(GetPersonList(), (person, state) =>
10                  {
11                      if (person.ID == 2)
12                          state.Stop();
13                      ThreadPoolMessage(person);
14                  });
15              Console.ReadKey();
16          }
17  
18          //模拟源数据
19          static IList<Person> GetPersonList()
20          {
21              var personList = new List<Person>();
22  
23              var person1 = new Person();
24              person1.ID = 1;
25              person1.Name = "Leslie";
26              person1.Age = 30;
27              personList.Add(person1);
28              ..........
29              return personList;
30          }
31  
32          //显示线程池现状
33          static void ThreadPoolMessage(Person person)
34          {
35              int a, b;
36              ThreadPool.GetAvailableThreads(out a, out b);
37              string message = string.Format("Person  ID:{0} Name:{1} Age:{2}\n" +
38                    "  CurrentThreadId is {3}\n  WorkerThreads is:{4}" +
39                    "  CompletionPortThreads is :{5}\n",
40                    person.ID, person.Name, person.Age,
41                    Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
42  
43              Console.WriteLine(message);
44          }
45      }

 1     public class Order
 2     {
 3         public int ID;
 4         public float Price;
 5     }
 6 
 7     public class OrderItem
 8     {
 9         public int ID;
10         public string Goods;
11         public int OrderID;
12         public float Price;
13         public int Count;
14     }
15 
16     class Program
17     {
18         static void Main(string[] args)
19         {
20             //设置最大线程数
21             ThreadPool.SetMaxThreads(1000, 1000);
22             float totalPrice = 0f;
23             //并行查询
24             var parallelResult = Parallel.ForEach(GetOrderList(),
25                      () => 0f,   //把参数初始值设为0
26                      (order, state, orderPrice) =>
27                      {
28                          //计算单个Order的价格
29                          orderPrice = GetOrderItem().Where(item => item.OrderID == order.ID)
30                               .Sum(item => item.Price * item.Count);
31                          order.Price = orderPrice;
32                          ThreadPoolMessage(order);
33                          
34                          return orderPrice;
35                      },
36                     (finallyPrice) =>
37                     {
38                         totalPrice += finallyPrice;//计算多个Order的总体价格
39                     }
40                 );
41             
42             while (!parallelResult.IsCompleted)
43                 Console.WriteLine("Doing Work!");
44 
45             Console.WriteLine("Total Price is:" + totalPrice);
46             Console.ReadKey();
47         }
48         //虚拟数据
49         static IList<Order> GetOrderList()
50         {
51             IList<Order> orderList = new List<Order>();
52             Order order1 = new Order();
53             order1.ID = 1;
54             orderList.Add(order1);
55             ............
56             return orderList;
57         }
58         //虚拟数据
59         static IList<OrderItem> GetOrderItem()
60         {
61             IList<OrderItem> itemList = new List<OrderItem>();
62 
63             OrderItem orderItem1 = new OrderItem();
64             orderItem1.ID = 1;
65             orderItem1.Goods = "iPhone 4S";
66             orderItem1.Price = 6700;
67             orderItem1.Count = 2;
68             orderItem1.OrderID = 1;
69             itemList.Add(orderItem1);
70             ...........
71             return itemList;
72         }
73 
74         //显示线程池现状
75         static void ThreadPoolMessage(Order order)
76         {
77             int a, b;
78             ThreadPool.GetAvailableThreads(out a, out b);
79             string message = string.Format("OrderID:{0}  OrderPrice:{1}\n" +
80                   "  CurrentThreadId is {2}\n  WorkerThreads is:{3}" +
81                   "  CompletionPortThreads is:{4}\n",
82                   order.ID, order.Price,
83                   Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
84 
85             Console.WriteLine(message);
86         }
87     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //设置最大线程数
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7             
 8             //任务并行
 9             Parallel.Invoke(option,
10                 PersonMessage, 
11                 ()=>ThreadPoolMessage(GetPersonList()[1]),  
12                 delegate(){
13                     ThreadPoolMessage(GetPersonList()[2]);
14                 });
15             Console.ReadKey();
16         }
17 
18         static void PersonMessage()
19         {
20             ThreadPoolMessage(GetPersonList()[0]);
21         }
22 
23         //显示线程池现状
24         static void ThreadPoolMessage(Person person)
25         {
26             int a, b;
27             ThreadPool.GetAvailableThreads(out a, out b);
28             string message = string.Format("Person  ID:{0} Name:{1} Age:{2}\n" +
29                   "  CurrentThreadId is {3}\n  WorkerThreads is:{4}" +
30                   "  CompletionPortThreads is :{5}\n",
31                   person.ID, person.Name, person.Age,
32                   Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
33 
34             Console.WriteLine(message);
35         }
36 
37         //模拟源数据
38         static IList<Person> GetPersonList()
39         {
40             var personList = new List<Person>();
41 
42             var person1 = new Person();
43             person1.ID = 1;
44             person1.Name = "Leslie";
45             person1.Age = 30;
46             personList.Add(person1);
47             ..........
48             return personList;
49         }
50     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             ThreadPool.SetMaxThreads(1000, 1000);
 6             Task.Factory.StartNew(() => ThreadPoolMessage());
 7             Console.ReadKey();
 8         }
 9 
10         //显示线程池现状
11         static void ThreadPoolMessage()
12         {
13             int a, b;
14             ThreadPool.GetAvailableThreads(out a, out b);
15             string message = string.Format("CurrentThreadId is:{0}\n" +
16                 "CurrentThread IsBackground:{1}\n" +
17                 "WorkerThreads is:{2}\nCompletionPortThreads is:{3}\n",
18                  Thread.CurrentThread.ManagedThreadId,
19                  Thread.CurrentThread.IsBackground.ToString(),
20                  a.ToString(), b.ToString());
21             Console.WriteLine(message);
22         }
23     }

 1 <html xmlns="http://www.w3.org/1999/xhtml">
 2 <head runat="server">
 3     <title></title>
 4     <script type="text/C#" runat="server">
 5         private static List<string> url=new List<string>();
 6 
 7         protected void Page_Load(object sender, EventArgs e)
 8         {
 9             if (!Page.IsPostBack)
10             {
11                 url.Clear();
12                 Application["Url"] = null;
13             }
14         }
15 
16         protected void CheckBox_CheckedChanged(object sender, EventArgs e)
17         {
18             CheckBox checkBox = (CheckBox)sender;
19             if (checkBox.Checked)
20                 url.Add(checkBox.Text);
21             else
22                 url.Remove(checkBox.Text);
23             Application["Url"]= url;
24         }
25 </script>
26 </head>
27 <body>
28     <form id="form1" runat="server" >
29     <div align="left">
30        <div align="center" style="float: left;">
31          <asp:Image ID="Image1" runat="server" ImageUrl="~/Images/A.jpg" /><br />
32          <asp:CheckBox ID="CheckBox1" runat="server" AutoPostBack="True" 
33                oncheckedchanged="CheckBox_CheckedChanged" Text="A.jpg" />
34        </div>
35        <div align="center" style="float: left">
36           <asp:Image ID="Image2" runat="server" ImageUrl="~/Images/B.jpg" /><br />
37           <asp:CheckBox ID="CheckBox2" runat="server" AutoPostBack="True" 
38                oncheckedchanged="CheckBox_CheckedChanged" Text="B.jpg" />
39        </div>
40        <div align="center" style="float: left">
41           <asp:Image ID="Image3" runat="server" ImageUrl="~/Images/C.jpg" /><br />
42           <asp:CheckBox ID="CheckBox3" runat="server" AutoPostBack="True" 
43                oncheckedchanged="CheckBox_CheckedChanged" Text="C.jpg" />
44        </div>
45        <div align="center" style="float: left">
46           <asp:Image ID="Image4" runat="server" ImageUrl="~/Images/D.jpg" /><br />
47           <asp:CheckBox ID="CheckBox4" runat="server" AutoPostBack="True" 
48                oncheckedchanged="CheckBox_CheckedChanged" Text="D.jpg" />
49        </div>
50        <div align="center" style="float: left">
51           <asp:Image ID="Image5" runat="server" ImageUrl="~/Images/E.jpg" /><br />
52           <asp:CheckBox ID="CheckBox5" runat="server" AutoPostBack="True" 
53                oncheckedchanged="CheckBox_CheckedChanged" Text="E.jpg" />
54        </div>        
55     </div>
56     </form>
57 </body>
58 </html>

 1 public class Handler : IHttpHandler 
 2 {
 3     public void ProcessRequest(HttpContext context)
 4     {
 5         //获取图片名，把图片数量写OutputStream
 6         List<String> urlList = (List<string>)context.Application["Url"];
 7         context.Response.OutputStream.Write(BitConverter.GetBytes(urlList.Count), 0, 4);
 8         
 9         //把图片转换成二进制数据
10         List<string> imageList = GetImages(urlList);
11         
12         //把每副图片长度写入OutputStream
13         foreach (string image in imageList)
14         {
15             byte[] imageByte=Convert.FromBase64String(image);
16             context.Response.OutputStream.Write(BitConverter.GetBytes(imageByte.Length),0,4);
17         }
18         
19         //把图片写入OutputStream
20         foreach (string image in imageList)
21         {
22             byte[] imageByte = Convert.FromBase64String(image);
23             context.Response.OutputStream.Write(imageByte,0,imageByte.Length);
24         }
25     }
26 
27     //获取多个图片的二进制数据
28     private List<string> GetImages(List<string> urlList)
29     {
30         List<string> imageList = new List<string>();
31         foreach (string url in urlList)
32             imageList.Add(GetImage(url));
33         return imageList;
34     }
35     
36     //获取单副图片的二进制数据
37     private string GetImage(string url)
38     {
39         string path = "E:/My Projects/Example/WebSite/Images/"+url;
40         FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read);
41         byte[] imgBytes = new byte[10240];
42         int imgLength = stream.Read(imgBytes, 0, 10240);       
43         return Convert.ToBase64String(imgBytes,0,imgLength);
44     }
45 
46     public bool IsReusable
47     {
48         get{ return false;}
49     }
50 }

 1     public partial class Form1 : Form
 2     {
 3         private CancellationTokenSource tokenSource = new CancellationTokenSource();
 4         
 5         public Form1()
 6         {
 7             InitializeComponent();
 8             ThreadPool.SetMaxThreads(1000, 1000);
 9         }
10 
11         private void downloadToolStripMenuItem_Click(object sender, EventArgs e)
12         {
13              Task.Factory.StartNew(GetImages,tokenSource.Token);
14         }
15 
16         private void cancelToolStripMenuItem_Click(object sender, EventArgs e)
17         {
18             tokenSource.Cancel();
19         }
20 
21         private void GetImages()
22         {
23             //发送请求，获取输出流
24             WebRequest webRequest = HttpWebRequest.Create("Http://localhost:5800/Handler.ashx"); 
25             Stream responseStream=webRequest.GetResponse().GetResponseStream();
26 
27             byte[] responseByte = new byte[81960];
28             IAsyncResult result=responseStream.BeginRead(responseByte,0,81960,null,null);
29             int responseLength = responseStream.EndRead(result);
30 
31             //获取图片数量
32             int imageCount = BitConverter.ToInt32(responseByte, 0);
33             
34             //获取每副图片的长度
35             int[] lengths = new int[imageCount];
36             for (int n = 0; n < imageCount; n++)
37             {
38                 int length = BitConverter.ToInt32(responseByte, (n + 1) * 4);
39                 lengths[n] = length;
40             }
41             try
42             {
43                 //保存图片
44                 for (int n = 0; n < imageCount; n++)
45                 {
46                     string path = string.Format("E:/My Projects/Example/Test/Images/pic{0}.jpg", n);
47                     FileStream file = new FileStream(path, FileMode.Create, FileAccess.ReadWrite);
48 
49                     //计算字节偏移量
50                     int offset = (imageCount + 1) * 4;
51                     for (int a = 0; a < n; a++)
52                         offset += lengths[a];
53 
54                     file.Write(responseByte, offset, lengths[n]);
55                     file.Flush();
56 
57                     //模拟操作
58                     Thread.Sleep(1000);
59 
60                     //检测CancellationToken变化
61                     tokenSource.Token.ThrowIfCancellationRequested();
62                 }
63             }
64             catch (OperationCanceledException ex)
65             {
66                 MessageBox.Show("Download cancel!");
67             }
68         }
69     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             var personList=GetPersonList().AsParallel() 
 6                    .Where(x=>x.Age>30);
 7             Console.ReadKey();
 8         }
 9 
10         //模拟源数据
11         static IList<Person> GetPersonList()
12         {
13             var personList = new List<Person>();
14 
15             var person1 = new Person();
16             person1.ID = 1;
17             person1.Name = "Leslie";
18             person1.Age = 30;
19             personList.Add(person1);
20             ...........
21             return personList;
22         }
23     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             var personList=GetPersonList().AsParallel().AsOrdered()
 6                 .Where(x=>x.Age<30);
 7             Console.ReadKey();
 8         }
 9 
10         static IList<Person> GetPersonList()
11         {......}
12     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             var personList=GetPersonList().AsParallel().WithDegreeOfParallelism(2)
 6                 .Where(x=>x.Age<30);
 7             Console.ReadKey();
 8         }
 9 
10         static IList<Person> GetPersonList()
11         {.........}
12     }

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             ThreadPool.SetMaxThreads(1000, 1000);
 6             GetPersonList().AsParallel().ForAll(person =>{
 7                 ThreadPoolMessage(person);
 8             });
 9             Console.ReadKey();
10         }
11 
12         static IList<Person> GetPersonList()
13         {.......}
14 
15          //显示线程池现状
16         static void ThreadPoolMessage(Person person)
17         {
18             int a, b;
19             ThreadPool.GetAvailableThreads(out a, out b);
20             string message = string.Format("Person  ID:{0} Name:{1} Age:{2}\n" +
21                   "  CurrentThreadId is {3}\n  WorkerThreads is:{4}" +
22                   "  CompletionPortThreads is :{5}\n",
23                   person.ID, person.Name, person.Age,
24                   Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
25             Console.WriteLine(message);
26         }
27     }

 1     class Program
 2     {
 3         static CancellationTokenSource tokenSource = new CancellationTokenSource();
 4 
 5         static void Main(string[] args)
 6         {
 7             Task.Factory.StartNew(Cancel);
 8             try
 9             {
10                 GetPersonList().AsParallel().WithCancellation(tokenSource.Token)
11                     .ForAll(person =>
12                     {
13                         ThreadPoolMessage(person);
14                     });
15             }
16             catch (OperationCanceledException ex)
17             { }
18             Console.ReadKey();
19         }
20 
21         //在10~50毫秒内发出停止信号
22         static void Cancel()
23         {
24             Random random = new Random();
25             Thread.Sleep(random.Next(10,50));
26             tokenSource.Cancel();
27         }
28 
29         static IList<Person> GetPersonList()
30         {......}
31 
32         //显示线程池现状
33         static void ThreadPoolMessage(Person person)
34         {
35             int a, b;
36             ThreadPool.GetAvailableThreads(out a, out b);
37             string message = string.Format("Person  ID:{0} Name:{1} Age:{2}\n" +
38                   "  CurrentThreadId is {3}\n  WorkerThreads is:{4}" +
39                   "  CompletionPortThreads is :{5}\n",
40                   person.ID, person.Name, person.Age,
41                   Thread.CurrentThread.ManagedThreadId, a.ToString(), b.ToString());
42             Console.WriteLine(message);
43         }
44     }
45          

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             ThreadPool.SetMaxThreads(1000, 1000);
 6 
 7             TimerCallback callback = new TimerCallback(ThreadPoolMessage);
 8             Timer t = new Timer(callback,"Hello Jack! ", 0, 1000);
 9             Console.ReadKey();
10         }
11 
12         //显示线程池现状
13         static void ThreadPoolMessage(object data)
14         {
15             int a, b;
16             ThreadPool.GetAvailableThreads(out a, out b);
17             string message = string.Format("{0}\n   CurrentThreadId is:{1}\n" +
18                 "   CurrentThread IsBackground:{2}\n" +
19                 "   WorkerThreads is:{3}\n   CompletionPortThreads is:{4}\n",
20                  data + "Time now is " + DateTime.Now.ToLongTimeString(),
21                  Thread.CurrentThread.ManagedThreadId,
22                  Thread.CurrentThread.IsBackground.ToString(),
23                  a.ToString(), b.ToString());
24             Console.WriteLine(message);
25         }
26     }

1 private void Method()
2 {
3       lock(this)
4       {
5           //在此进行的操作能保证在同一时间内只有一个线程对此对象操作
6       }
7 }

 1 class Control
 2 {
 3       private object obj=new object();
 4       
 5       public void Method()
 6       {
 7             lock(obj)
 8             {.......}
 9       }
10 }

 1 class Control
 2 {
 3       private object obj=new object();
 4  
 5       public void Method()
 6       {
 7             Monitor.Enter(obj);
 8             try
 9             {......}
10             catch(Excetion ex)
11             {......}
12             finally
13             {
14                 Monitor.Exit(obj);
15             }
16       }
17 }
18          

1 class Example
2 {
3       private int a=1;
4 
5       public void AddOne()
6       {
7              int newA=Interlocked.Increment(ref a);
8       }
9 }

1 public void SetData()
2 {
3       Interlocked.Exchange(ref a,100);
4 }

1 public void CompareAndExchange()
2 {
3     Interlocked.CompareExchange(ref a,100,1);
4 }