C#中构建多线程应用程序

　 引言

　随着双核 四核等多核处理器的推广 多核处理器或超线程单核处理器的计算机已很常见 基于多核处理的编程技术也开始受到程序员们普遍关注 这其中一个重要的方面就是构建多线程应用程序（因为不使用多线程的话 开发人员就不能充分发挥多核计算机的强大性能）

　本文针对的是构建基于单核计算机的多线程应用程序 目的在于介绍多线程相关的基本概念 内涵 以及如何通过System Threading命名空间的类 委托和BackgroundWorker组件等三种手段构建多线程应用程序

　本文如果能为刚接触多线程的朋友起到抛砖引玉的作用也就心满意足了 当然 本人才疏学浅 文中难免会有不足或错误的地方 恳请各位朋友多多指点

　 理解多线程

　我们通常理解的应用程序就是一个 exe文件 当运行 exe应用程序以后 系统会在内存中为该程序分配一定的空间 同时加载一些该程序所需的资源 其实这就可以称为创建了一个进程 可以通过Windows任务管理器查看这个进程的相关信息 如映像名称 用户名 内存使用 PID（唯一的进程标示）等 如图下所示

　

　而线程则只是进程中的一个基本执行单元 一个应用程序往往只有一个程序入口 如

　[STAThread]

　static void Main()   //应用程序主入口点

　{

　Application EnableVisualStyles();

　Application SetCompatibleTextRenderingDefault(false);

　Application Run(new MainForm());

　}

　进程会包含一个进入此入口的线程 我们称之为主线程 其中 特性 [STAThread] 指示应用程序的默认线程模型是单线程单元（相关信息可参考 us/library/system stathreadattribute(VS ) aspx） 只包含一个主线程的进程是线程安全的 相当于程序仅有一条工作线 只有完成了前面的任务才能执行排在后面的任务

　然当在程序处理一个很耗时的任务 如输出一个大的文件或远程访问数据库等 此时的窗体界面程序对用户而言基本像是没反应一样 菜单 按钮等都用不了 因为窗体上控件的响应事件也是需要主线程来执行的 而主线程正忙着干其他的事 控件响应事件就只能排队等著主线程忙完了再执行

　为了克服单线程的这个缺陷 Win API可以让主线程再创建其他的次线程 但不论是主线程还是次线程都是进程中独立的执行单元 可以同时访问共享的数据 这样就有了多线程这个概念

　相信到这 应该对多线程有个比较感性的认识了 但笔者在这要提醒一下 基于单核计算机的多线程其实只是 *** 作系统施展的一个障眼法而已（但这不会干扰我们理解构建多线程应用程序的思路） 他并不能缩短完成所有任务的时间 有时反而还会因为使用过多的线程而降低性能 延长时间 之所以这样 是因为对于单CPU而言 在一个单位时间（也称时间片）内 只能执行一个线程 即只能干一件事 当一个线程的时间片用完时 系统会将该线程挂起 下一个时间内再执行另一个线程 如此 CPU以时间片为间隔在多个线程之间交替执行运算（其实这里还与每个线程的优先级有关 级别高的会优先处理） 由于交替时间间隔很短 所以造成了各个线程都在 同时 工作的假象 而如果线程数目过多 由于系统挂起线程时要记录线程当前的状态数据等 这样又势必会降低程序的整体性能 但对于这些 多核计算机就能从本质上（真正的同时工作）提高程序的执行效率

　 线程异步与线程同步

　从线程执行任务的方式上可以分为线程同步和线程异步 而为了方便理解 后面描述中用 同步线程 指代与线程同步相关的线程 同样 用 异步线程 表示与线程异步相关的线程

　线程异步就是解决类似前面提到的执行耗时任务时界面控件不能使用的问题 如创建一个次线程去专门执行耗时的任务 而其他如界面控件响应这样的任务交给另一个线程执行（往往由主线程执行） 这样 两个线程之间通过线程调度器短时间（时间片）内的切换 就模拟出多个任务 同时 被执行的效果

　线程异步往往是通过创建多个线程执行多个任务 多个工作线同时开工 类似多辆在宽广的公路上并行的汽车同时前进 互不干扰（读者要明白 本质上并没有 同时 仅仅是 *** 作系统玩的一个障眼法 但这个障眼法却对提高我们的程序与用户之间的交互 以及提高程序的友好性很有用 不是吗）

　在介绍线程同步之前 先介绍一个与此紧密相关的概念——并发问题

　前面提到 线程都是独立的执行单元 可以访问共享的数据 也就是说 在一个拥有多个次线程的程序中 每个线程都可以访问同一个共享的数据 再稍加思考你会发现这样可能会出问题 由于线程调度器会随机的挂起某一个线程（前面介绍的线程间的切换） 所以当线程a对共享数据D的访问（修改 删除等 *** 作）完成之前被挂起 而此时线程b又恰好去访问数据D 那么线程b访问的则是一个不稳定的数据 这样就会产生非常难以发现bug 由于是随机发生的 产生的结果是不可预测的 这样样的bug也都很难重现和调试 这就是并发问题

　为了解决多线程共同访问一个共享资源（也称互斥访问）时产生的并发问题 线程同步就应运而生了 线程同步的机理 简单的说 就是防止多个线程同时访问某个共享的资源 做法很简单 标记访问某共享资源的那部分代码 当程序运行到有标记的地方时 CLR（具体是什么可以先不管 只要知道它能控制就行）对各线程进行调整 如果已有线程在访问一资源 CLR就会将其他访问这一资源的线程挂起 直到前一线程结束对该资源的访问 这样就保证了同一时间只有一个线程访问该资源 打个比方 就如某资源放在只有一独木桥相连的孤岛上 如果要使用该资源 大家就得排队 一个一个来 前面的回来了 下一个再去 前面的没回来 后面的就原地待命

　这里只是把基本的概念及原理做了一个简单的阐述 不至于看后面的程序时糊里糊涂的 具体如何编写代码 下面的段落将做详细介绍

　 创建多线程应用程序

　这里做一个简单的说明 下面主要通过介绍通过System Threading命名空间的类 委托和BackgroundWorker组件三种不同的手段构建多线程应用程序 具体会从线程异步和线程同步两个方面来阐述

　 通过System Threading命名空间的类构建

　在 NET平台下 System Threading命名空间提供了许多类型来构建多线程应用程序 可以说是专为多线程服务的 由于本文仅是想起到一个 抛砖引玉 的作用 所以对于这一块不会探讨过多 过深 主要使用System Threading Thread类

　先从System Threading Thread类本身相关的一个小例子说起 代码如下 解释见注释

　using System;

　using System Threading; //引入System Threading命名空间

　namespace MultiThread

　{

　class Class

　{

　static void Main(string[] args)

　{

　Console WriteLine( 显示当前线程的相关信息 );

　//声明线程变量并赋值为当前线程

　Thread primaryThread = Thread CurrentThread;

　//赋值线程的名称

　primaryThread Name = 主线程 ;

　//显示线程的相关信息

　Console WriteLine( 线程的名字 { } primaryThread Name);

　Console WriteLine( 线程是否启动？ { } primaryThread IsAlive);

　Console WriteLine( 线程的优先级 { } primaryThread Priority);

　Console WriteLine( 线程的状态 { } primaryThread ThreadState);

　Console ReadLine();

　}

　}

　}

　输出结果如下

　 显示当前线程的相关信息

　线程的名字 主线程

　线程是否启动？ True

　线程的优先级 Normal

　线程的状态 Running

　对于上面的代码不想做过多解释 只说一下Thread CurrentThread得到的是执行当前代码的线程

　 异步调用线程

　这里先说一下前台线程与后台线程 前台线程能阻止应用程序的终止 既直到所有前台线程终止后才会彻底关闭应用程序 而对后台线程而言 当所有前台线程终止时 后台线程会被自动终止 不论后台线程是否正在执行任务 默认情况下通过Thread Start()方法创建的线程都自动为前台线程 把线程的属性IsBackground设为true时就将线程转为后台线程

　下面先看一个例子 该例子创建一个次线程执行打印数字的任务 而主线程则干其他的事 两者同时进行 互不干扰

　using System;

　using System Threading;

　using System Windows Forms;

　namespace MultiThread

　{

　class Class

　{

　static void Main(string[] args)

　{

　Console WriteLine( 两个线程同时工作 );

　//主线程 因为获得的是当前在执行Main()的线程

　Thread primaryThread = Thread CurrentThread;

　primaryThread Name = 主线程 ;

　Console WriteLine( > { } 在执行主函数 Main() Thread CurrentThread Name);

　//次线程 该线程指向PrintNumbers()方法

　Thread SecondThread = new Thread(new ThreadStart(PrintNumbers));

　SecondThread Name = 次线程 ;

　//次线程开始执行指向的方法

　SecondThread Start();

　//同时主线程在执行主函数中的其他任务

　MessageBox Show( 正在执行主函数中的任务 主线程在工作 );

　Console ReadLine();

　}

　//打印数字的方法

　static void PrintNumbers()

　{

　Console WriteLine( > { } 在执行打印数字函数 PrintNumber() Thread CurrentThread Name);

　Console WriteLine( 打印数字 );

　for (int i = ; i < ; i++)

　{

　Console Write( { } i);

　//Sleep()方法使当前线程挂等待指定的时长在执行 这里主要是模仿打印任务

　Thread Sleep( );

　}

　Console WriteLine();

　}

　}

　}

　程序运行后会看到一个窗口d出 如图所示 同时控制台窗口也在不断的显示数字

　

　输出结果为

　 两个线程同时工作

　 > 主线程 在执行主函数 Main()

　 > 次线程 在执行打印数字函数 PrintNumber()

　打印数字

　

　这里稍微对 Thread SecondThread = new Thread(new ThreadStart(PrintNumbers)); 这一句做个解释 其实 ThreadStart 是 System Threading 命名空间下的一个委托 其声明是 public delegate void ThreadStart() 指向不带参数 返回值为空的方法 所以当使用 ThreadStart 时 对应的线程就只能调用不带参数 返回值为空的方法 那非要指向含参数的方法呢？在System Threading命名空间下还有一个ParameterizedThreadStart 委托 其声明是 public delegate void ParameterizedThreadStart(object obj) 可以指向含 object 类型参数的方法 这里不要忘了 object 可是所有类型的父类哦 有了它就可以通过创建各种自定义类型 如结构 类等传递很多参数了 这里就不再举例说明了

　 并发问题

　这里再通过一个例子让大家切实体会一下前面说到的并发问题 然后再介绍线程同步

　using System;

　using System Threading;

　namespace MultiThread

　{

　class Class

　{

　static void Main(string[] args)

　{

　Console WriteLine( 并发问题演示 );

　//创建一个打印对象实例

　Printer printer = new Printer();

　//声明一含 个线程对象的数组

　Thread[] threads = new Thread[ ];

　for (int i = ; i < ; i++)

　{

　//将每一个线程都指向printer的PrintNumbers()方法

　threads[i] = new Thread(new ThreadStart(printer PrintNumbers));

　//给每一个线程编号

　threads[i] Name = i ToString() + 号线程 ;

　}

　//开始执行所有线程

　foreach (Thread t in threads)

　t Start();

　Console ReadLine();

　}

　}

　//打印类

　public class Printer

　{

　//打印数字的方法

　public void PrintNumbers()

　{

　Console WriteLine( > { } 正在执行打印任务 开始打印数字 Thread CurrentThread Name);

　for (int i = ; i < ; i++)

　{

　Random r = new Random();

　//为了增加冲突的几率及 使各线程各自等待随机的时长

　Thread Sleep( r Next( ));

　//打印数字

　Console Write( { } i);

　}

　Console WriteLine();

　}

　}

　}

　上面的例子中 主线程产生的 个线程同时访问同一个对象实例printer的方法PrintNumbers() 由于没有锁定共享资源（注意 这里是指控制台） 所以在PrintNumbers()输出到控制台之前 调用PrintNumbers()的线程很可能被挂起 但不知道什么时候（或是否有）挂起 导致得到不可预测的结果 如下是两个不同的结果（当然 读者的运行结果可能会是其他情形）

　

　情形一

　

　情形二

　 线程同步

　线程同步的访问方式也称为阻塞调用 即没有执行完任务不返回 线程被挂起 可以使用C#中的lock关键字 在此关键字范围类的代码都将是线程安全的 lock关键字需定义一个标记 线程进入锁定范围是必须获得这个标记 当锁定的是一个实例级对象的私有方法时使用方法本身所在对象的引用就可以了 将上面例子中的打印类Printer稍做改动 添加lock关键字 代码如下

　//打印类

　public class Printer

　{

　public void PrintNumbers()

　{

　//使用lock关键字 锁定d的代码是线程安全的

　lock (this)

　{

　Console WriteLine( > { } 正在执行打印任务 开始打印数字 Thread CurrentThread Name);

　for (int i = ; i < ; i++)

　{

　Random r = new Random();

　//为了增加冲突的几率及 使各线程各自等待随机的时长

　Thread Sleep( r Next( ));

　//打印数字

　Console Write( { } i);

　}

　Console WriteLine();

　}

　}

　}

　}

　同步后执行结果如下

　

　也可以使用System Threading命名空间下的Monitor类进行同步 两者内涵是一样的 但Monitor类更灵活 这里就不在做过多的探讨 代码如下

　//打印类

　public class Printer

　{

　public void PrintNumbers()

　{

　Monitor Enter(this);

　try

　{

　Console WriteLine( > { } 正在执行打印任务 开始打印数字 Thread CurrentThread Name);

　for (int i = ; i < ; i++)

　{

　Random r = new Random();

　//为了增加冲突的几率及 使各线程各自等待随机的时长

　Thread Sleep( r Next( ));

　//打印数字

　Console Write( { } i);

　}

　Console WriteLine();

　}

　finally

　{

　Monitor Exit(this);

　}

　}

　}

　输出结果与上面的一样

　 通过委托构建多线程应用程序

　在看下面的内容时要求对委托有一定的了解 如果不清楚的话推荐参考一下博客园张子阳的《C# 中的委托和事件》 里面对委托与事件进行由浅入深的较系统的讲解

　这里先举一个关于委托的简单例子 具体解说见注释

　using System;

　namespace MultiThread

　{

　//定义一个指向包含两个int型参数 返回值为int型的函数的委托

　public delegate int AddOp(int x int y);

　class Program

　{

　static void Main(string[] args)

　{

　//创建一个指向Add()方法的AddOp对象p

　AddOp pAddOp = new AddOp(Add);

　//使用委托间接调用方法Add()

　Console WriteLine( + = { } pAddOp( ));

　Console ReadLine();

　}

　//求和的函数

　static int Add(int x int y)

　{

　int sum = x + y;

　return sum;

　}

　}

　}

　运行结果为

　 + =

　 线程异步

　先说明一下 这里不打算讲解委托线程异步或同步的参数传递 获取返回值等 只是做个一般性的开头而已 如果后面有时间了再另外写一篇关于多线程中参数传递 获取返回值的文章

　注意观察上面的例子会发现 直接使用委托实例 pAddOp( ) 就调用了求和方法 Add() 很明显 这个方法是由主线程执行的 然而 委托类型中还有另外两个方法——BeginInvoke()和EndInvoke() 下面通过具体的例子来说明 将上面的例子做适当改动 如下

　using System;

　using System Threading;

　using System Runtime Remoting Messaging;

　namespace MultiThread

　{

　//声明指向含两个int型参数 返回值为int型的函数的委托

　public delegate int AddOp(int x int y);

　class Program

　{

　static void Main(string[] args)

　{

　Console WriteLine( 委托异步线程 两个线程 同时 工作 );

　//显示主线程的唯一标示

　Console WriteLine( 调用Main()的主线程的线程ID是 { } Thread CurrentThread ManagedThreadId);

　//将委托实例指向Add()方法

　AddOp pAddOp = new AddOp(Add);

　//开始委托次线程调用 委托BeginInvoke()方法返回的类型是IAsyncResult

　//包含这委托指向方法结束返回的值 同时也是EndInvoke()方法参数

　IAsyncResult iftAR = pAddOp BeginInvoke( null null);

　Console WriteLine( nMain()方法中执行其他任务 n );

　int sum = pAddOp EndInvoke(iftAR);

　Console WriteLine( + = { } sum);

　Console ReadLine();

　}

　//求和方法

　static int Add(int x int y)

　{

　//指示调用该方法的线程ID ManagedThreadId是线程的唯一标示

　Console WriteLine( 调用求和方法 Add()的线程ID是 { } Thread CurrentThread ManagedThreadId);

　//模拟一个过程 停留 秒

　Thread Sleep( );

　int sum = x + y;

　return sum;

　}

　}

　}

　运行结果如下

　 委托异步线程 两个线程 同时 工作

　调用Main()的主线程的线程ID是

　Main()方法中执行其他任务

　调用求和方法 Add()的线程ID是

　 + =

　 线程同步

　委托中的线程同步主要涉及到上面使用的pAddOp BeginInvoke( null null)方法中后面两个为null的参数 具体的可以参考相关资料 这里代码如下 解释见代码注释

　using System;

　using System Threading;

　using System Runtime Remoting Messaging;

　namespace MultiThread

　{

　//声明指向含两个int型参数 返回值为int型的函数的委托

　public delegate int AddOp(int x int y);

　class Program

　{

　static void Main(string[] args)

　{

　Console WriteLine( 线程同步 阻塞 调用 两个线程工作 );

　Console WriteLine( Main() invokee on thread { } Thread CurrentThread ManagedThreadId);

　//将委托实例指向Add()方法

　AddOp pAddOp = new AddOp(Add);

　IAsyncResult iftAR = pAddOp BeginInvoke( null null);

　//判断委托线程是否执行完任务

　//没有完成的话 主线程就做其他的事

　while (!iftAR IsCompleted)

　{

　Console WriteLine( Main()方法工作中 );

　Thread Sleep( );

　}

　//获得返回值

　int answer = pAddOp EndInvoke(iftAR);

　Console WriteLine( + = { } answer);

　Console ReadLine();

　}

　//求和方法

　static int Add(int x int y)

　{

　//指示调用该方法的线程ID ManagedThreadId是线程的唯一标示

　Console WriteLine( 调用求和方法 Add()的线程ID是 { } Thread CurrentThread ManagedThreadId);

　//模拟一个过程 停留 秒

　Thread Sleep( );

　int sum = x + y;

　return sum;

　}

　}

　}

　运行结果如下

　 线程同步 阻塞 调用 两个线程工作

　Main() invokee on thread

　Main()方法工作中

　调用求和方法 Add()的线程ID是

　Main()方法工作中

　Main()方法工作中

　Main()方法工作中

　Main()方法工作中

　 + =

　 BackgroundWorker组件

　BackgroundWorker组件位于工具箱中 用于方便的创建线程异步的程序 新建一个WindowsForms应用程序 界面如下

　

　代码如下 解释参见注释

　private void button _Click(object sender EventArgs e)

　{

　try

　{

　//获得输入的数字

　int numOne = int Parse(this textBox Text);

　int numTwo = int Parse(this textBox Text);

　//实例化参数类

　AddParams args = new AddParams(numOne numTwo);

　//调用RunWorkerAsync()生成后台线程 同时传入参数

　this backgroundWorker RunWorkerAsync(args);

　}

　catch (Exception ex)

　{

　MessageBox Show(ex Message);

　}

　}

　//backgroundWorker新生成的线程开始工作

　private void backgroundWorker _DoWork(object sender DoWorkEventArgs e)

　{

　//获取传入的AddParams对象

　AddParams args = (AddParams)e Argument;

　//停留 秒 模拟耗时任务

　Thread Sleep( );

　//返回值

　e Result = args a + args b;

　}

　//当backgroundWorker 的DoWork中的代码执行完后会触发该事件

　//同时 其执行的结果会包含在RunWorkerCompletedEventArgs参数中

　private void backgroundWorker _RunWorkerCompleted(object sender RunWorkerCompletedEventArgs e)

　{

　//显示运算结果

　MessageBox Show( 运行结果为 + e Result ToString() 结果 );

　}

　}

　//参数类 这个类仅仅起到一个记录并传递参数的作用

　class AddParams

　{

　public int a b;

　public AddParams(int numb int numb )

　{

　a = numb ;

　b = numb ;

　}

　}

　注意 在计算结果的同时 窗体可以随意移动 也可以重新在文本框中输入信息 这就说明主线程与backgroundWorker组件生成的线程是异步的

　 总结

lishixinzhi/Article/program/net/201311/11400

大概是asynchronous

socket的缩写吧，异步

套接字

，用堵塞套接字的话，函数只有完成相应 *** 作才会返回，如recv等接收函数，只有有数据时才返回，如果没有数据就一直等待，现实中很少用，用的时候一般都是多线程，要不然程序可能停留在相应函数那里，无法相应其它消息或 *** 作，只对本线程有影响，无关其它线程。这个类可以改变模式，改成非阻塞性的套接字。

第1篇 Visual C++网络编程基础

第1章 Visual C++网络编程概述(教学视频：21分钟)

11 网络基础知识

111 OSI七层网络模型

1I2 TCP/IP协议

113 C/S编程模型

12 网络编程基础

121 Sockets套接字

122 网络字节顺序

13 WindowsSockets介绍

131 CAsyncSocket类

132 CSocket类

14 小结

第2章 Socket套接字编程(教学视频：73分钟)

21 寻址方式和字节顺序

211 寻址方式

212 字节顺序

213 Socket相关函数

22 Winsock网络程序开发流程

221 VC中创建工程的步骤

222 Winsock编程流程

223 基于UDP的Sockets编程

224基于UDP的Sockets编程

23 网络程序实例应用

231 TCP客户端程序

232 TCP服务器程序

24 小结

第3章 多线程与异步套接字编程(教学视频：116分钟)

31 多线程技术

311 基本概念

312 创建线程

32 实现线程同步

321 临界区对象

322 事件对象

323 互斥对象

33 进程间通信

331 邮槽

332 命名管道

333 匿名管道

334 小结

34 设置I/O模式

341 异步I/O模式

342 WSAAsyncSelect方法

35 小结

第2篇 Visual C++网络编程典型应用

第4章 FTP浏览器(教学视频：95分钟)

41 FTP工作原理

411 FTP数据结构

412 FTP数据传输模式

413 服务器进行连接

414 登录验证

415 关闭数据连接

416 FTP常用命令

417 数据校验与重发控制

42 登录FTP服务器

421 连接FTP服务器

422 登录FTP服务器

43 FTP文件处理

431 CSocketFile类的使用

432 使用CArchive类进行串行化

433 获取FTP服务器文件信息

434 上传文件

435 下载文件

44 创建客户端

441 建立工程

442 定义CFtp类

443 使用CFtp类编程

45 小结

第5章 网页浏览器(教学视频：72分钟)

51 HTTP请求

511 GET方式

512 POSI方式

513 请求消息

52 HTTP响应

521 响应状态信息

522 响应标题字段信息

523 实体标题字段信息

524 实体数据

53 制作个性化界面

531 工具栏编程

532 添加消息响应

533 如何实现收藏夹的功能

554使用MicrosoftWeb浏览器控件

541 建立MFC工程

542 添加控件

543 控件对象属性方法

55 CHtmlView类

551 CHtmlView类

552 建立继承关系

553 地址栏消息响应

554 实现查看源文件功能

555 实现刷新功能

56 小结

第6章 网络通信器(教学视频：58分钟)

61 通信原理

611 通信连接

612 发送接收

62 发送端程序

621 创建连接套接字

622 创建发送套接字

623 实现发送功能

63 接收端程序

631 监听端口

632 接收数据

64 界面美化编程

641 界面初始化

642 设置服务器窗口图标

643 显示服务器启动时间

644 服务器状态栏编程

65 ，J、结

第7章 邮件收发器(教学视频：107分钟)

71 调用Windows自带的邮件发送程序

711 调用Windows进程

712 CreateProcess(1函数

72 SMTP会话过程

721 怎么连接服务器

722 SMTP命令

723 发送命令与接收响应

73 发送邮件

731 界面设计

732 界面初始化代码

733 添加服务器设置对话框

734 使用服务器设置对话框

735 记录程序配置信息

736 设置并连接服务器

737 构造邮件

738 发送邮件

739 发送邮件实例

74 接收邮件

741 POP3简介

742 接收邮件实例界面

743 使用接收邮件对话框

744 接收邮件

745 实现接收邮件功能

746 封装客户端发送与接收功能

747 显示邮件数据

748 代码分析

75 小结

第8章 网络文件传输器(教学视频：87分钟)

81 CFile类

811 构造函数

812 读写文件

813 文件关闭

814 文件定位

……

第9 实用播放器(教学视频：120分钟)

第10 P2P网络播放器(教学视频：107分钟)

第11 Q版聊天软件(学视频：60分钟)

第3篇 Visual C++串口通信

第12 串口通信基础(教学视频：22分钟)

第13 串口通信编程应用(教学视频：69分钟)

第14 VC发送手机短信(教学视频：73分钟)

python如何提高socket速率，方法如下：

1、使用非阻塞模式：使用socket的setblocking函数可以将socket设置为非阻塞模式，这样可以避免socket处于等待状态，从而提高速度。

2、使用多线程和多进程：利用多线程和多进程可以同时处理多个socket连接，从而提高socket速率。

3、减少数据传输：减少socket发送数据量，可以减少消息传输时间，从而提高socket速度。

4、调整TCP参数：可以通过调整网络参数，如TCP缓冲区大小，TCP超时时间等等，来提高socket速度。

Python是一种计算机编程语言，它简单易学，功能强大，可以用来做日常任务，也可以用来开发复杂的软件和应用程序。它的语法简洁，易于理解，可以大大减少开发时间，节约开发费用。

这个问法不对

CSocket是

CAsyncSocket

的

派生类

他们都支持TCP和UDP

网络通信协议

,TCP

面向连接

,UDP

面向无连接

,CSocket比CAsyncSocket多了对阻塞同步的支持

　转载自fychit创意空间 很早以前就想写写linux下多线程编程和windows下的多线程编程了，但是每当写时又不知道从哪个地方写起，怎样把自己知道的东西都写出来，下面我就谈谈linux多线程及线程同步，并将它和windows的多线程进行比较，看看他们之间有什么相同点和不同的地方。

　　其实最开始我是搞windows下编程的，包括windows编程，windows 驱动，包括usb驱动，ndis驱动,pci驱动，1394驱动等等，同时也一条龙服务，做windows下的应用程序开发，后面慢慢的我又对linux开发产生比较深的兴趣和爱好，就转到搞linux开发了。在接下来的我还会写一些博客，主要是写linux编程和windows编程的区别吧，现在想写的是linux下usb驱动和windows下usb驱动开发的区别，这些都是后话，等我将linux多线程和windows多线程讲解完后，我再写一篇usb驱动，谈谈windows 和linux usb驱动的东东。好了，言归正传。开始将多线程了。

　　首先我们讲讲为什么要采用多线程编程，其实并不是所有的程序都必须采用多线程，有些时候采用多线程，性能还没有单线程好。所以我们要搞清楚，什么时候采用多线程。采用多线程的好处如下：

　　(1)因为多线程彼此之间采用相同的地址空间，共享大部分的数据，这样和多进程相比，代价比较节俭，因为多进程的话，启动新的进程必须分配给它独立的地址空间，这样需要数据表来维护代码段，数据段和堆栈段等等。

　　(2)多线程和多进程相比，一个明显的优点就是线程之间的通信了，对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。但是对于多线程就不一样了。他们之间可以直接共享数据，比如最简单的方式就是共享全局变量。但是共享全部变量也要注意哦，呵呵，必须注意同步，不然后果你知道的。呵呵。

　　(3)在多cpu的情况下，不同的线程可以运行不同的cpu下，这样就完全并行了。

　　反正我觉得在这种情况下，采用多线程比较理想。比如说你要做一个任务分2个步骤，你为提高工作效率，你可以多线程技术，开辟2个线程，第一个线程就做第一步的工作，第2个线程就做第2步的工作。但是你这个时候要注意同步了。因为只有第一步做完才能做第2步的工作。这时，我们可以采用同步技术进行线程之间的通信。

　　针对这种情况，我们首先讲讲多线程之间的通信，在windows平台下，多线程之间通信采用的方法主要有：

　　(1)共享全局变量,这种方法是最容易想到的，呵呵，那就首先讲讲吧，比如说吧，上面的问题，第一步要向第2步传递收据，我们可以之间共享全局变量，让两个线程之间传递数据，这时主要考虑的就是同步了，因为你后面的线程在对数据进行 *** 作的时候，你第一个线程又改变了数据的内容，你不同步保护，后果很严重的。你也知道，这种情况就是读脏数据了。在这种情况下，我们最容易想到的同步方法就是设置一个bool flag了，比如说在第2个线程还没有用完数据前，第一个线程不能写入。有时在2个线程所需的时间不相同的时候，怎样达到最大效率的同步，就比较麻烦了。咱们可以多开几个缓冲区进行 *** 作。就像生产者消费者一样了。如果是2个线程一直在跑的，由于时间不一致，缓冲区迟早会溢出的。在这种情况下就要考虑了，是不让数据写入还是让数据覆盖掉老的数据，这时候就要具体问题具体分析了。就此打住，呵呵。就是用bool变量控制同步，linux 和windows是一样的。

　　既然讲道了这里，就再讲讲其它同步的方法。同样 针对上面的这个问题，共享全局变量同步问题。除了采用bool变量外，最容易想到的方法就是互斥量了。呵呵，也就是传说中的加锁了。windows下加锁和linux下加锁是类似的。采用互斥量进行同步，要想进入那段代码，就先必须获得互斥量。

　　linux上互斥量的函数是：

　　windows下互斥量的函数有：createmutex 创建一个互斥量，然后就是获得互斥量waitforsingleobject函数，用完了就释放互斥量ReleaseMutex(hMutex)，当减到0的时候 内核会才会释放其对象。下面是windows下与互斥的几个函数原型。

　　HANDLE WINAPI CreateMutex(

　　__in LPSECURITY_ATTRIBUTES lpMutexAttributes,

　　__in BOOL bInitialOwner,

　　__in LPCTSTR lpName

　　);

　　可以可用来创建一个有名或无名的互斥量对象

　　第一参数 可以指向一个结构体SECURITY_ATTRIBUTES　一般可以设为null；

　　第二参数 指当时的函数是不是感应感应状态 FALSE为当前拥有者不会创建互斥

　　第三参数 指明是否是有名的互斥对象 如果是无名 用null就好。

　　DWORD WINAPI WaitForSingleObject(

　　__in HANDLE hHandle,

　　__in DWORD dwMilliseconds

　　);

　　第一个是 创建的互斥对象的句柄。第二个是 表示将在多少时间之后返回 如果设为宏INFINITE 则不会返回 直到用户自己定义返回。

　　对于linux *** 作系统，互斥也是类似的，只是函数不同罢了。在linux下，和互斥相关的几个函数也要闪亮登场了。

　　pthread_mutex_init函数：初始化一个互斥锁；

　　pthread_mutex_destroy函数：注销一个互斥锁；

　　pthread_mutex_lock函数：加锁，如果不成功，阻塞等待；

　　pthread_mutex_unlock函数：解锁；

　　pthread_mutex_trylock函数：测试加锁，如果不成功就立即返回，错误码为EBUSY;

　　至于这些函数的用法，google上一搜，就出来了，呵呵，在这里不多讲了。windows下还有一个可以用来保护数据的方法，也是线程同步的方式

　　就是临界区了。临界区和互斥类似。它们之间的区别是，临界区速度快，但是它只能用来同步同一个进程内的多个线程。临界区的获取和释放函数如下：

　　EnterCriticalSection() 进入临界区; LeaveCriticalSection()离开临界区。 对于多线程共享内存的东东就讲到这里了。

　　(2)采用消息机制进行多线程通信和同步，windows下面的的消息机制的函数用的多的就是postmessage了。Linux下的消息机制，我用的较少，就不在这里说了，如果谁熟悉的，也告诉我，呵呵。

　　(3)windows下的另外一种线程通信方法就是事件和信号量了。同样针对我开始举得例子，2个线程同步，他们之间传递信息，可以采用事件(Event)或信号量(Semaphore),比如第一个线程完成生产的数据后，就必须告诉第2个线程，他已经把数据准备好了，你可以来取走了。第2个线程就把数据取走。呵呵，这里可以采用消息机制，当第一个线程准备好数据后，就直接postmessage给第2个线程，按理说采用postmessage一个线程就可以搞定这个问题了。呵呵，不是重点，省略不讲了。

　　对于linux，也有类似的方法，就是条件变量了，呵呵，这里windows和linux就有不同了。要特别讲讲才行。

　　对于windows，采用事件和信号量同步时候，都会使用waitforsingleobject进行等待的，这个函数的第一个参数是一个句柄，在这里可以是Event句柄，或Semaphore句柄，第2个参数就是等待的延迟，最终等多久，单位是ms，如果这个参数为INFINITE，那么就是无限等待了。释放信号量的函数为ReleaseSemaphore（）；释放事件的函数为SetEvent。当然使用这些东西都要初始化的。这里就不讲了。Msdn一搜，神马都出来了，呵呵。神马都是浮云！

　　对于linux *** 作系统，是采用条件变量来实现类似的功能的。Linux的条件变量一般都是和互斥锁一起使用的，主要的函数有：

　　pthread_mutex_lock ,

　　pthread_mutex_unlock,

　　pthread_cond_init

　　pthread_cond_signal

　　pthread_cond_wait

　　pthread_cond_timewait

VC对SOCKET编程提供的支持并不是特别丰富，

主要是MFC中的CAsyncSocket、CSocket，所以著作不多。

但是，Windows API 对SOCKET支持就丰富多了，MFC的那两个类也是基于

WinSOCK的异步选择模型。著作也有很多。推荐你一本：

<<Windows 网络编程技术>>

这本书里的知识要是消化掌握了，那你就足以应付多数Windows环境下的网络开发了。

我认为本书的重点章节是

第7章，winsock 基础

第8章，winsock I/O 方法

这两章掌握了，编写网络模块就不成问题了。