编写一个Windows多线程控制台程序

在MFC里直接用AfxBeginThread就可以了啊。

使用CWinThread声明一个线程，然后定义一个线程函数，在要开启线程的地方使用AfxBeginThread这个线程函数就可以了~

例如：

CWinThread pThreadTest;

UINT _TestThread(LPVOID lparam)

{

//sth you want to do

return 0;

}

//在适当地方开启线程

pThreadTest = ::AfxBeginThread(_TestThread,this);

。

通过多进程来实现，用这两个命令：

调用格式： 〈逻辑型〉 启动线程 （子程序指针 欲执行的子程序，［整数型 参数数据］，［整数型变量 线程句柄］） - 多线程支持库->多线程控制

英文名称：CreateThread

创建并启动一条线程，可重复使用以创建多条线程，成功返回真，失败返回假。本命令为初级命令。

参数<1>的名称为“欲执行的子程序”，类型为“子程序指针（SubPtr）”。本参数提供创建线程时欲启动的子程序，根据是否需要传递参数数据，该子程序必须没有或具有一个整数型参数，否则将出错。

参数<2>的名称为“参数数据”，类型为“整数型（int）”，可以被省略。本参数提供线程被启动时传递到欲启动子程序的整数数据。如果本参数未被省略，此时被启动子程序必须接收一个整数型参数，否则将出错。

参数<3>的名称为“线程句柄”，类型为“整数型（int）”，可以被省略，提供参数数据时只能提供变量。如果提供了本参数，将向参数变量写入线程句柄（Windows下为HANDLE，Linux下为pthread_t），请在适当的时机关闭该句柄。如果不提供本参数接收线程句柄，内部将自动处理线程句柄。

*** 作系统需求： Windows、Linux

————————————————————————————————————————

调用格式： 〈逻辑型〉 关闭线程句柄 （整数型 线程句柄） - 多线程支持库->多线程控制

英文名称：CloseThreadHandle

返回真表示已成功关闭线程句柄。在Linux下，如果线程已经结束，本命令可能返回假。本命令为初级命令。

参数<1>的名称为“线程句柄”，类型为“整数型（int）”。可通过“启动线程”的第三个参数获取线程句柄。

*** 作系统需求： Windows、Linux

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

按F1关闭线程，要注册热键：

调用格式： 〈整数型〉 注册热键 （整数型 窗口句柄，整数型 标签句柄，整数型 功能键，整数型 主热键） - 扩展功能支持库一->热键功能

英文名称：RegHotKey

注册系统热键，返回一个热键标识，失败返回0。本命令为初级命令。

参数<1>的名称为“窗口句柄”，类型为“整数型（int）”。窗口句柄。

参数<2>的名称为“标签句柄”，类型为“整数型（int）”。使用标签的反馈事件来接受热键，反馈事件中的第一个参数为热键标识，第二个参数无效。

参数<3>的名称为“功能键”，类型为“整数型（int）”，初始值为“0”。可以为：0-无功能键；1-CTRL键状态；2-SHIFT键状态；4-ALT键状态或各键状态值之和。

参数<4>的名称为“主热键”，类型为“整数型（int）”。键代码，可以使用易语言中的键代码常量。

*** 作系统需求： Windows

using System;

using SystemDiagnostics;

using SystemThreading;

namespace BaiDu

{

class Program

{

static void LaunchNotePad() //启动记事本的函数

{

ProcessStart("notepad");

}

static void Main(string[] args)

{

Thread []thread = new Thread[10]; // 创建10个线程

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

{

thread[i] = new Thread(new ThreadStart(LaunchNotePad)); //每个线程启动一个记事本

}

for (int i = 0; i < 10; i++ ) // 启动10个线程

{

thread[i]Start();

}

ConsoleReadKey();

}

}

}

我可以帮助你，你先设置我最佳答案后，我百度Hii教你。

主要内容：

进程是资源分配的最小单位，每个进程都有独立的代码和数据空间，一个进程包含 1 到 n 个线程。线程是 CPU 调度的最小单位，每个线程有独立的运行栈和程序计数器，线程切换开销小。

Java 程序总是从主类的 main 方法开始执行，main 方法就是 Java 程序默认的主线程，而在 main 方法中再创建的线程就是其他线程。在 Java 中，每次程序启动至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。每次使用 Java 命令启动一个 Java 程序，就相当于启动一个 JVM 实例，而每个 JVM 实例就是在 *** 作系统中启动的一个进程。

多线程可以通过继承或实现接口的方式创建。

Thread 类是 JDK 中定义的用于控制线程对象的类，该类中封装了线程执行体 run() 方法。需要强调的一点是，线程执行先后与创建顺序无关。

通过 Runnable 方式创建线程相比通过继承 Thread 类创建线程的优势是避免了单继承的局限性。若一个 boy 类继承了 person 类，boy 类就无法通过继承 Thread 类的方式来实现多线程。

使用 Runnable 接口创建线程的过程：先是创建对象实例 MyRunnable，然后将对象 My Runnable 作为 Thread 构造方法的入参，来构造出线程。对于 new Thread(Runnable target) 创建的使用同一入参目标对象的线程，可以共享该入参目标对象 MyRunnable 的成员变量和方法，但 run() 方法中的局部变量相互独立，互不干扰。

上面代码是 new 了三个不同的 My Runnable 对象，如果只想使用同一个对象，可以只 new 一个 MyRunnable 对象给三个 new Thread 使用。

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程有新建、可运行、阻塞、等待、定时等待、死亡 6 种状态。一个具有生命的线程，总是处于这 6 种状态之一。 每个线程可以独立于其他线程运行，也可和其他线程协同运行。线程被创建后，调用 start() 方法启动线程，该线程便从新建态进入就绪状态。

NEW 状态（新建状态） 实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是 NEW 状态：

RUNNABLE 状态（就绪状态）：

阻塞状态有 3 种：

如果一个线程调用了一个对象的 wait 方法， 那么这个线程就会处于等待状态（waiting 状态）直到另外一个线程调用这个对象的 notify 或者 notifyAll 方法后才会解除这个状态。

run() 里的代码执行完毕后，线程进入终结状态（TERMINATED 状态）。

线程状态有 6 种：新建、可运行、阻塞、等待、定时等待、死亡。

我们看下 join 方法的使用：

运行结果：

我们来看下 yield 方法的使用：

运行结果：

线程与线程之间是无法直接通信的，A 线程无法直接通知 B 线程，Java 中线程之间交换信息是通过共享的内存来实现的，控制共享资源的读写的访问，使得多个线程轮流执行对共享数据的 *** 作，线程之间通信是通过对共享资源上锁或释放锁来实现的。线程排队轮流执行共享资源，这称为线程的同步。

Java 提供了很多同步 *** 作（也就是线程间的通信方式），同步可使用 synchronized 关键字、Object 类的 wait/notifyAll 方法、ReentrantLock 锁、无锁同步 CAS 等方式来实现。

ReentrantLock 是 JDK 内置的一个锁对象，用于线程同步（线程通信），需要用户手动释放锁。

运行结果：

这表明同一时间段只能有 1 个线程执行 work 方法，因为 work 方法里的代码需要获取到锁才能执行，这就实现了多个线程间的通信，线程 0 获取锁，先执行，线程 1 等待，线程 0 释放锁，线程 1 继续执行。

synchronized 是一种语法级别的同步方式，称为内置锁。该锁会在代码执行完毕后由 JVM 释放。

输出结果跟 ReentrantLock 一样。

Java 中的 Object 类默认是所有类的父类，该类拥有 wait、 notify、notifyAll 方法，其他对象会自动继承 Object 类，可调用 Object 类的这些方法实现线程间的通信。

除了可以通过锁的方式来实现通信，还可通过无锁的方式来实现，无锁同 CAS（Compare-and-Swap，比较和交换）的实现，需要有 3 个 *** 作数：内存地址 V，旧的预期值 A，即将要更新的目标值 B，当且仅当内存地址 V 的值与预期值 A 相等时，将内存地址 V 的值修改为目标值 B，否则就什么都不做。

我们通过计算器的案例来演示无锁同步 CAS 的实现方式，非线程安全的计数方式如下：

线程安全的计数方式如下：

运行结果：

线程安全累加的结果才是正确的，非线程安全会出现少计算值的情况。JDK 15 开始，并发包里提供了原子 *** 作的类，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 还提供了用原子方式将当前值自增 1 或自减 1 的方法，在多线程程序中，诸如 ++i 或 i++ 等运算不具有原子性，是不安全的线程 *** 作之一。 通常我们使用 synchronized 将该 *** 作变成一个原子 *** 作，但 JVM 为此种 *** 作提供了原子 *** 作的同步类 Atomic，使用 AtomicInteger 做自增运算的性能是 ReentantLock 的好几倍。

上面我们都是使用底层的方式实现线程间的通信的，但在实际的开发中，我们应该尽量远离底层结构，使用封装好的 API，例如 JUC 包（javautilconcurrent，又称并发包）下的工具类 CountDownLath、CyclicBarrier、Semaphore，来实现线程通信，协调线程执行。

CountDownLatch 能够实现线程之间的等待，CountDownLatch 用于某一个线程等待若干个其他线程执行完任务之后，它才开始执行。

CountDownLatch 类只提供了一个构造器：

CountDownLatch 类中常用的 3 个方法：

运行结果：

CyclicBarrier 字面意思循环栅栏，通过它可以让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重复使用，所以有循环之意。

相比 CountDownLatch，CyclicBarrier 可以被循环使用，而且如果遇到线程中断等情况时，可以利用 reset() 方法，重置计数器，CyclicBarrier 会比 CountDownLatch 更加灵活。

CyclicBarrier 提供 2 个构造器：

上面的方法中，参数 parties 指让多少个线程或者任务等待至 barrier 状态；参数 barrierAction 为当这些线程都达到 barrier 状态时会执行的内容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 个重载版本。下面方法用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。

而下面的方法则是让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行任务。

运行结果：

CyclicBarrier 用于一组线程互相等待至某个状态，然后这一组线程再同时执行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 类是一个计数信号量，它可以设定一个阈值，多个线程竞争获取许可信号，执行完任务后归还，超过阈值后，线程申请许可信号时将会被阻塞。Semaphore 可以用来 构建对象池，资源池，比如数据库连接池。

假如在服务器上运行着若干个客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程呢？

给方法加同步锁，保证同一时刻只能有一个线程去调用此方法，其他所有线程排队等待，但若有 10 个数据库连接，也只有一个能被使用，效率太低。另外一种方法，使用信号量，让信号量许可与数据库可用连接数为相同数量，10 个数据库连接都能被使用，大大提高性能。

上面三个工具类是 JUC 包的核心类，JUC 包的全景图就比较复杂了：

JUC 包（javautilconcurrent）中的高层类（Lock、同步器、阻塞队列、Executor、并发容器）依赖基础类（AQS、非阻塞数据结构、原子变量类），而基础类是通过 CAS 和 volatile 来实现的。我们尽量使用顶层的类，避免使用基础类 CAS 和 volatile 来协调线程的执行。JUC 包其他的内容，在其他的篇章会有相应的讲解。

Future 是一种异步执行的设计模式，类似 ajax 异步请求，不需要同步等待返回结果，可继续执行代码。使 Runnable（无返回值不支持上报异常）或 Callable（有返回值支持上报异常）均可开启线程执行任务。但是如果需要异步获取线程的返回结果，就需要通过 Future 来实现了。

Future 是位于 javautilconcurrent 包下的一个接口，Future 接口封装了取消任务，获取任务结果的方法。

在 Java 中，一般是通过继承 Thread 类或者实现 Runnable 接口来创建多线程， Runnable 接口不能返回结果，JDK 15 之后，Java 提供了 Callable 接口来封装子任务，Callable 接口可以获取返回结果。我们使用线程池提交 Callable 接口任务，将返回 Future 接口添加进 ArrayList 数组，最后遍历 FutureList，实现异步获取返回值。

运行结果：

上面就是异步线程执行的调用过程，实际开发中用得更多的是使用现成的异步框架来实现异步编程，如 RxJava，有兴趣的可以继续去了解，通常异步框架都是结合远程 >

实现方法进程与指定cpu绑定

：SetProcessAffinityMask(GetCurrentProcess(),dwMask);

线程与指定cpu绑定：

SetThreadAffinityMask(GetCurrentThread(),dwMask);dwMask为CPU序号的或运算值：1（0001）

代表只运行在CPU1，2（0010）代表只运行在CPU2，3（0011）代表可以运行在CPU1和CPU2

，以此类推。

设置之前最好判断一下系统有几个CPU：

SYSTEM_INFOSystemInfo;

GetSystemInfo(&SystemInfo);CPU个数：SystemInfodwNumberOfProcessors

当前启用的CPU序号：

SystemInfodwActiveProcessorMask

，Mask representing the set of processors configured into the system Bit 0 is processor 0;

bit 31 is processor 31

CPU亲缘性介绍

按照默认设置，当系统将线程分配给处理器时，Windows使用软亲缘性来进行 *** 作。这意味着如果所有其他因素相同的话，它将设法在它上次运行的那个处理器上运行线程。让线程留在单个处理器上，有助于重复使用仍然在处理器的内存高速缓存中的数据。

有一种新的计算机结构，称为NUMA（非统一内存访问），在该结构中，计算机包含若干块插件板，每个插 件板上有4个CPU和它自己的内存区。

当CPU访问的内存是它自己的插件板上的内存时，NUMA系统运行的性能最好。如果CPU需要访问位于另一个插件板上的内 存时，就会产生巨大的性能降低。在这样的环境中，就需要限制来自一个进程中的线程在共享同一个插件版的CPU上运行。为了适应这种计算机结构的需要，Windows允许你设置进程和线程的亲缘性。换句话说，你可以控制哪个CPU能够运行某些线程。这称为硬亲缘性。请注意，子进程可以继承进程的亲缘性。

注意：（1）无论计算机中实际拥有多少个CPU，Windows98及以前系统只使用一个CPU，上述API不被支持。

（2）在大多数环境中，改变线程的亲缘性就会影响调度程序有效地在 各个CPU之间移植线程的能力，而这种能力可以最有效地使用CPU时间。

应用场景举例：

将UI线程限制在一个CPU，将其他实时性要求较高的线程限制在另一个CPU。这样，当UI需要占用大量CPU时间时，就不会拖累其他实时性要求较高的线程的执行

。同样可以将UI线程与一些优先级不高但耗时的异步运算线程设置在不同CPU上，避免UI给人卡顿的感觉。

引言

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

本文针对的是构建基于单核计算机的多线程应用程序 目的在于介绍多线程相关的基本概念 内涵 以及如何通过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

以上就是关于编写一个Windows多线程控制台程序全部的内容，包括:编写一个Windows多线程控制台程序、多个应用程序通过同一条数据线程同时运行怎么实现、C语言Windows控制台程序线程怎么创建。~ 谢谢各位大大回答。~等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！