.NET控件必须被自身创建的线程访问，在任何线程中调用:InvokeRequired,Invoke,BeginInvoke,EndInvoke,CreateGraphics方法都是安全的，可在其他线程中调用这5个方法，使其通过委托(待确认)在控件自身创建线程中得到调用。
lock　　　InterLocked（原子）

http://www.cnblogs.com/jintianhu/archive/2010/11/19/1881494.html

http://www.cnblogs.com/xd125/archive/2007/12/12/992406.html

thread

一旦一个进程所有的前台线程都终止后，CLR（通用语言运行环境）将通过调用任意一个存活中的后台进程的Abort()方法来彻底终止进程。

Monitor 类琐定  生产者／消费者

http://kb.cnblogs.com/page/42530/2/

threadPool  manualResetEvent AutoResetEvent 同步
http://www.cnblogs.com/vcool/archive/2008/05/13/1195213.html

timer 可以看出线程是一个系统时间片一直在轮循的

while (s.tmr!=null)
            {
                Thread.Sleep(0);
            }

mutex 互斥

===============

异步线程：http://www.cnblogs.com/jeffreyzhao/archive/2008/02/24/use-async-operation-properly.html

线程池：　http://www.cnblogs.com/jeffreyzhao/archive/2009/07/22/thread-pool-1-the-goal-and-the-clr-thread-pool.html

====================

线程=》异步操作
因为创建一个线程的代价较高，因此我们使用线程池设法复用线程。

==============？
线程安全
死锁  http://www.cnblogs.com/jeffreyzhao/archive/2009/09/10/dotnet-deadlock-detect.html
=====================

dotnet存在2个默认线程池:1,CLR线程池(工作线程);2, I/O线程池;      (暂未提供添加线程池方法)
I/O线程使用情况
{
FileStream操作：BeginRead、BeginWrite。调用BeginRead/BeginWrite时会发起一个异步操作，但是只有在创建FileStream时传入FileOptions.Asynchronous参数才能获取真正的IOCP支持，否则BeginXXX方法将会使用默认定义在Stream基类上的实现。Stream基类中BeginXXX方法会使用委托的BeginInvoke方法来发起异步调用——这会使用一个额外的线程来执行任务。虽然当前调用线程立即返回了，但是数据的读取或写入操作依旧占用着另一个线程（IOCP支持的异步操作时不需要线程的），因此并没有任何“节省”，反而还很有可能降低了应用程序的性能，因为额外的线程切换会造成性能损失。

• DNS操作：BeginGetHostByName、BeginResolve。
• Socket操作：BeginAccept、BeginConnect、BeginReceive等等。
• WebRequest操作：BeginGetRequestStream、BeginGetResponse。
• SqlCommand操作：BeginExecuteReader、BeginExecuteNonQuery等等。这可能是开发一个Web应用时最常用的异步操作了。如果需要在执行数据库操作时得到IOCP支持，那么需要在连接字符串中标记Asynchronous Processing为true（默认为false），否则在调用BeginXXX操作时就会抛出异常。
• WebServcie调用操作：例如.NET 2.0或WCF生成的Web Service Proxy中的BeginXXX方法、WCF中ClientBase<TChannel>的InvokeAsync方法。

}
(时间片)timeslice又被称为quantum，不同操作系统中定义的这个值并不相同。在Windows客户端操作系统（XP，Vista）中时间片默认为2个clock interval，在服务器操作系统（2003，2008）中默认为12个clock interval（在主流系统上，1个clock interval大约10到15毫秒）。服务器操作系统使用较长的时间片，是因为一般服务器上运行的程序比客户端要少很多，且更注重性能和吞吐量，而客户端系统更注重响应能力——而且，如果您真需要的话，时间片的长度也是可以调整的。
操作多个线程池:smartThreadPool  http://www.codeproject.com/KB/threads/smartthreadpool.aspx
“上下文切换（context switch）"
操作系统中会定义一个“时间片（timeslice）”²，当发现一个线程执行时间超过这个时间，便会把它撤下，换上另外一个。这样看起来，多个线程——也就是多个任务在同时运行了
并行:多个cpu每个一个进程/线程任务运行 ;  并发:多个进程/线程一个cpu,时间片轮询切换任务.

ASP.NET在得到一个请求后，也会将这个请求处理的任务交由CLR线程池去执行
http://www.cnblogs.com/jeffreyzhao/archive/2009/01/19/lab-async-request.html

http://www.cnblogs.com/JeffreyZhao/archive/2009/10/20/thread-pool-3-lab.html 老赵试验结果：

线程的创建 "每秒不超过2个"

• 原来最小线程数量为5时，只有4个线程可以立即执行。经过进一步尝试，最小线程数量为10时，也只有9个线程可以立即执行。
• 原来线程池创建线程的速度并非永远是“每秒2个”，而一些资料上写着“每秒不超过2个”的确是确切的说法。

但是，我们还是验证了以下几个结论：

• 在线程池最小线程数量的范围之内，尽可能多的任务立即执行。
• 线程池使用使用每秒不超过2个的频率创建线程（1秒一个或0.5秒一个）。
• 当达到线程池最大线程数时（第6秒），停止创建新线程。
• 在旧任务执行完毕后，新任务立即执行。

windows API

异步Socket: http://www.cnblogs.com/wzd24/archive/2007/06/13/782833.html

　　使用异步Socket: 在服务端连接比较多而且是长连接的情况下

(*)http://blog.csdn.net/hulihui/archive/2008/10/27/3158613.aspx

(*)http://supersocket.codeplex.com/releases/view/64669
http://csharp.net-informations.com/communications/csharp-multi-threaded-server-socket.htm
http://www.cnblogs.com/JimmyZhang/archive/2008/09/16/1291854.html

===================================

#region myAnsy        public void startAnsy()        {            Socket ansyListener = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);            var _address = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];            var _port = 8888;            IPEndPoint localEP = new IPEndPoint(_address, _port);            ansyListener.Bind(localEP);            ansyListener.Listen(100);            Socket ansyAptListener = ansyListener.Accept();            byte[] buffer=new byte[1000];
            AnsySocketInfo asi = new AnsySocketInfo();            asi.skt = ansyAptListener;
            ansyAptListener.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None,new AsyncCallback(ansyReceive),asi);            MessageBox.Show("go");
        }
        public void ansyReceive(IAsyncResult ay)        {            Socket ansyAptListener = ((AnsySocketInfo)ay.AsyncState).skt;            int recCount= ansyAptListener.EndReceive(ay); //当主线程执行完成时，本线程会报错。            //Thread.Sleep(3000);            MessageBox.Show("resule"+recCount.ToString());        }
        #endregion

#region 2
        Socket _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);        
        public void ansy2()        {            /*IPHostEntry iphe = Dns.GetHostEntry(Dns.GetHostName());            IPAddress ip = iphe.AddressList[0];            IPEndPoint ipep = new IPEndPoint(ip, 8888);            */            var _address = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];            var _port = 8888;            IPEndPoint localEP = new IPEndPoint(_address, _port);            _listener.Bind(localEP);            _listener.Listen(100);
             Thread _acceptWorkThread = new Thread(AcceptWorkThread);            _acceptWorkThread.Start();        }
        private void AcceptWorkThread()        {            //while (_isListener)            //{                UserInfo info = new UserInfo();//这个UserInfo是用来保存客户信息的。                                Socket socket = _listener.Accept();                info.socket = socket;                //这里进行其它处理。                socket.BeginReceive(info.Buffer, 0, info.Buffer.Length,SocketFlags.None,ReceiveCallBack,info);//这里向系统投递一个接收信息的请求，并为其指定ReceiveCallBack做为回调函数            //}        }
        //         private void ReceiveCallBack(IAsyncResult ar)        {            UserInfo info = (UserInfo)ar.AsyncState;            Socket handler = info.socket;            int readCount = 0;            try            {                readCount = handler.EndReceive(ar);//调用这个函数来结束本次接收并返回接收到的数据长度。            }            catch (SocketException)//出现Socket异常就关闭连接            {                //CloseSocket(info);//这个函数用来关闭客户端连接                handler.Close();                return;            }            catch            {            }            if (readCount > 0)            {                byte[] buffer = new byte[readCount];                Buffer.BlockCopy(info.Buffer, 0, buffer, 0, readCount);                //Analyzer(info, buffer);//这个函数用来处理接收到的信息。 。。。。。。。。。。。。。。                try                {                    handler.BeginReceive(info.Buffer, 0, info.Buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), info);//向系统投递下一个接收请求                }                catch (SocketException) //出现Socket异常就关闭连接                {                    //CloseSocket(info);                    handler.Close();                }                catch                {                }            }            else //如果接收到0字节的数据说明客户端关闭了Socket，那我们也要关闭Socket            {                //CloseSocket(info);                handler.Close();            }        }
        //        public void Send(Socket socket, byte[] message)        {            try            {                UserInfo info = new UserInfo();                byte[] _byte=new byte[10];
                info.socket.BeginSend(message,0, _byte.Length, SocketFlags.None, new AsyncCallback(SendCallBack), info);//这里向系统投递一个发送数据的请求，并指定一个回调函数。            }            catch (SocketException ex)            {                //CloseSocket(info);                            }            catch            {            }        }
        //
        private void SendCallBack(IAsyncResult ar)        {            UserInfo info = (UserInfo)ar.AsyncState;            try            {                info.socket.EndSend(ar);//调用这个函数来结束本次发送。            }            catch            {            }        }
        class UserInfo        {            public Socket socket=null;            public byte[] Buffer;        }                #endregion

外网IPsocket,访问某IP内的局域网PC：可以在路由器中配置端口号访问到对应IP机器，（转发规则--虚拟服务器） 虚拟服务器定义了广域网服务端口和局域网网络服务器之间的映射关系，所有对该广域网服务端口的访问将会被重定位给通过IP地址指定的局域网网络服务器。

由www.LcKey.com 提供支持