下载文档原格式
Halcon算法加速的基础知识（多核并⾏GPU）⼀、提⾼Halcon的运算速度，有以下⼏种⽅法：1、Multithreading(多线程)2、Automatic Parallelization(⾃动操作并⾏化)3、Compute devices，利⽤GPU提速，如果显卡性能好，⾄少可以提⾼5~10倍的运算速度⼆、多线程1、官⽅⾃带的例程get_operator_info.hdev，可以查看⽀持多线程的算⼦；1 * Determine the multithreading information2 get_multithreading_operators (TypeExclusive, TypeMutual, TypeReentrant, TypeIndependent)3 * ⾃定义函数展开之后,有get_operator_info算⼦4 * get names of all operators of the library5 get_operator_name ('', OperatorNames)6 get_operator_info (OperatorNames[Index], 'parallelization', Information)2、官⽅的⼿册C:\Program Files\MVTec\HALCON-19.11-Progress\doc\pdf\manuals\programmers_guide.pdfChapter 2 Parallel Programming and HALCONC:\Program Files\MVTec\HALCON-19.11-Progress\doc\pdf\reference\reference_hdevelop.pdfChapter 25 System --- 25.6 Multithreading三、多核并⾏看看官⽅的说明，关于HALCON-多核性能：1、算⼦⾃动并⾏化(AOP)Automatic Operator Parallelization (AOP)多核和多处理器的计算机显著提升了计算机视觉系统的速度。
多线程是一种并行计算的方式，可以同时执行多个任务，从而提高程序运行速度。
在计算机系统中，每个线程都有自己的程序计数器、寄存器集合、栈和局部变量等。
多个线程可以共享全局变量和堆内存，从而实现任务的并行处理。
一、多线程的概念与好处多线程是指一个进程中同时运行多个线程，每个线程处理不同的任务。
相比于单线程，多线程可以更充分地利用计算机系统的资源，提高程序的运行效率。
多线程的好处有以下几个方面：1. 提高程序运行速度：通过同时执行多个任务，可以实现并行计算，从而减少程序的运行时间。
2. 提高计算机系统的资源利用率：通过合理安排线程的执行顺序，可以充分利用计算机系统的CPU、内存等资源，提高系统的整体性能。
3. 增强用户体验：多线程可以使程序的响应更加迅速，用户操作不再被等待，提高了用户的操作体验。
二、多线程的实现方式在Java语言中，多线程可以通过继承Thread类或者实现Runnable接口来实现。
下面分别介绍这两种方式。
1. 继承Thread类：通过继承Thread类，重写其run方法，即可创建一个新的线程。
然后调用start方法启动线程，并通过join方法等待线程执行完毕。
这种方式简单直接，但是由于Java不支持多重继承，因此在使用时可能会受到限制。
2. 实现Runnable接口：通过实现Runnable接口，重写其run方法，然后创建Thread对象，将实现了Runnable接口的对象作为参数传入，即可创建一个新的线程。
与继承Thread类相比，实现Runnable接口的方式更具灵活性，因为Java支持多个接口的实现。
三、多线程的注意事项在使用多线程的过程中，需要注意以下几点：1. 线程安全：多线程访问共享资源时，可能会导致数据不一致或者冲突的问题，因此需要采取一定的措施来保证线程的安全性，如使用锁机制、同步代码块等。
2. 上下文切换：在多线程之间进行切换时，需要保存和恢复线程的上下文信息，可能涉及到一定的开销。
LabVIEW的多线程编程提高任务并行度LabVIEW是一款广泛应用于科学研究、工程设计和控制系统开发的编程语言和开发环境。
多线程编程是LabVIEW的一个重要特性，可以在同一个应用程序中同时执行多个任务，大大提高任务的并行度。
本文将介绍LabVIEW的多线程编程，探讨其如何提高任务的并行度。
一、LabVIEW的多线程编程简介LabVIEW是一种基于数据流图的编程语言，通过将数据和信号线连接起来，实现任务的并行执行。
在LabVIEW中，任务被称为“虚拟仪器”，可以通过多线程编程实现并行处理。
在LabVIEW中，多线程编程可以通过以下方式实现：1. 创建多个并行执行的虚拟仪器：可以在LabVIEW中创建多个虚拟仪器，每个虚拟仪器代表一个任务，通过并行执行多个虚拟仪器来实现任务的并行度提升。
2. 使用多线程结构：LabVIEW提供了多种多线程编程结构，如并行循环、多线程队列等。
通过这些结构，可以将任务分成多个子任务，并行执行，提高任务的并行度。
3. 利用硬件资源：LabVIEW可以与各种硬件设备连接，如传感器、执行器等。
通过使用硬件资源，可以实现并行处理，提高任务的并行度。
二、LabVIEW多线程编程的好处LabVIEW的多线程编程具有以下好处：1. 提高任务的执行效率：通过多线程编程，可以将任务划分成多个子任务，并行执行。
这样可以充分利用计算机的多核处理能力，提高任务的执行效率。
2. 实时性和响应性：LabVIEW的多线程编程可以实现实时任务的并行处理，提高系统的响应速度和实时性。
3. 简化复杂任务：LabVIEW的多线程编程可以将复杂任务分解成多个简单的子任务，并行执行。
这样可以降低任务的复杂度，提高开发效率。
三、LabVIEW多线程编程的应用场景LabVIEW的多线程编程适用于以下场景：1. 大规模数据处理：当需要对大量数据进行处理时，可以使用LabVIEW的多线程编程，将数据分成多个子任务并行处理，提高数据处理的效率。
第1篇一、实验目的1. 理解多线程的概念和作用。
2. 掌握多线程的创建、同步和通信方法。
3. 熟悉Java中多线程的实现方式。
4. 提高程序设计能力和实际应用能力。
二、实验环境1. 操作系统：Windows 102. 开发工具：IntelliJ IDEA3. 编程语言：Java三、实验内容本次实验主要完成以下任务：1. 创建多线程程序，实现两个线程分别执行不同的任务。
2. 使用同步方法实现线程间的同步。
3. 使用线程通信机制实现线程间的协作。
四、实验步骤1. 创建两个线程类，分别为Thread1和Thread2。
```javapublic class Thread1 extends Thread {@Overridepublic void run() {// 执行Thread1的任务for (int i = 0; i < 10; i++) {System.out.println("Thread1: " + i);}}}public class Thread2 extends Thread {@Overridepublic void run() {// 执行Thread2的任务for (int i = 0; i < 10; i++) {System.out.println("Thread2: " + i);}}}```2. 创建一个主类，在主类中创建两个线程对象，并启动它们。
```javapublic class Main {public static void main(String[] args) {Thread thread1 = new Thread1();Thread thread2 = new Thread2();thread1.start();thread2.start();}```3. 使用同步方法实现线程间的同步。
```javapublic class SynchronizedThread extends Thread {private static int count = 0;@Overridepublic void run() {for (int i = 0; i < 10; i++) {synchronized (SynchronizedThread.class) {count++;System.out.println(Thread.currentThread().getName() + ": " + count);}}}}public class Main {public static void main(String[] args) {Thread thread1 = new SynchronizedThread();Thread thread2 = new SynchronizedThread();thread1.start();thread2.start();}```4. 使用线程通信机制实现线程间的协作。
JAVA多线程的使用场景与注意事项总结Java多线程是指在一个程序中同时运行多个线程，每个线程都有自己的执行代码，但是又共享同一片内存空间和其他系统资源。
多线程的使用场景和注意事项是我们在开发中需要关注的重点，下面将详细进行总结。
一、Java多线程的使用场景：1.提高程序的执行效率：多线程可以充分利用系统资源，将一些耗时的操作放到一个线程中执行，避免阻塞主线程，提高程序的执行效率。
2.实现并行计算：多线程可以将任务拆分成多个子任务，每个子任务分配给一个线程来执行，从而实现并行计算，提高计算速度。
3.响应性能提升：多线程可以提高程序的响应性能，比如在用户界面的开发中，可以使用多线程来处理用户的输入和操作，保证界面的流畅性和及时响应。
4.实时性要求高：多线程可以实现实时性要求高的任务，比如监控系统、实时数据处理等。
5.任务调度与资源管理：多线程可以实现任务的调度和资源的管理，通过线程池可以更好地掌控任务的执行情况和使用系统资源。
二、Java多线程的注意事项：1.线程安全性：多线程操作共享资源时，要注意线程安全问题。
可以通过使用锁、同步方法、同步块等方式来解决线程安全问题。
2.死锁：多线程中存在死锁问题，即多个线程相互等待对方释放资源，导致程序无法继续执行。
要避免死锁问题，应尽量减少同步块的嵌套和锁的使用。
3.内存泄漏：多线程中存在内存泄漏问题，即线程结束后，线程的资源没有得到释放，导致内存占用过高。
要避免内存泄漏问题，应及时释放线程资源。
4.上下文切换：多线程的切换会带来上下文切换的开销，影响程序的执行效率。
要注意合理分配线程的数量，避免过多线程的切换。
5. 线程同步与通信：多线程之间需要进行同步和通信，以保证线程之间的正确协调和数据的一致性。
可以使用synchronized关键字、wait(和notify(方法等方式进行线程同步和通信。
6.线程池的使用：在多线程编程中，可以使用线程池来管理线程的创建和销毁，可以减少线程的创建和销毁的开销，提高程序的性能。
多线程技术在图像处理中的应用与优势随着计算机性能的提升和图像处理的广泛应用，如何利用多线程技术来提高图像处理性能成为了一个重要的课题。
本文将深入探讨多线程技术在图像处理中的应用与优势，以及如何优化多线程算法来提高图像处理效率。
一、多线程技术的应用范围多线程技术在图像处理中有着广泛的应用范围。
其中包括图像的加载和保存、图像的滤波和增强、以及图像的分割和识别等。
由于图像处理算法通常需要对大量的像素点进行操作，使用单线程算法进行处理效率往往较低。
而利用多线程技术可以将图像的处理任务分配给多个线程并行执行，从而提高图像处理的效率。
二、多线程技术的优势1. 充分利用多核处理器的优势：现代计算机多数都配备了多核处理器，利用多线程技术可以最大程度地发挥多核处理器的优势，使不同核心同时处理不同的图像区域，从而提高图像处理的速度。
2. 算法的可扩展性：多线程技术具有良好的可扩展性，可以根据图像处理任务的要求动态调整线程数目。
对于不同规模的图像处理任务，可以灵活分配线程资源，确保图像处理的效率和质量。
3. 减少等待时间：图像处理常常涉及到大量的IO操作，如图像的加载和保存。
使用多线程技术可以将IO操作与图像处理任务分离，不影响图像处理的同时，减少了等待时间，提高了整体处理效率。
三、优化多线程算法来提高图像处理效率1. 调整线程数目：根据硬件性能和图像处理任务的要求，合理调整线程数目。
过多的线程可能导致线程间的竞争和调度开销，而过少的线程可能无法充分利用多核处理器的优势。
2. 数据划分策略：合理划分数据，将图像分成多个块，每个线程负责处理一块图像数据，避免数据冲突和竞争。
可以根据图像的特点和处理任务的复杂度，将图像按行、列或者区域分割。
3. 任务调度策略：合理分配任务，使每个线程都能够尽量平均地获得处理时间。
可以采用任务队列的方式，将待处理的图像数据按照一定规则分发给各个线程。
4. 合理使用同步机制：在多线程环境下，需要合理使用同步机制来保证数据的一致性和线程的安全性。
多线程的课程设计一、课程目标知识目标：1. 让学生理解多线程的基本概念，掌握多线程的编程方法和技巧。
2. 使学生了解多线程在软件开发中的应用场景，掌握多线程同步、互斥和通信等关键技术。
3. 帮助学生了解操作系统中线程调度策略，理解多线程程序的性能影响因素。
技能目标：1. 培养学生运用所学知识独立编写多线程程序的能力。
2. 提高学生分析、解决多线程编程中遇到问题的能力。
3. 培养学生运用多线程技术优化程序性能的能力。
情感态度价值观目标：1. 激发学生对计算机编程的兴趣，培养良好的编程习惯。
2. 培养学生具备团队协作意识，提高沟通表达能力。
3. 增强学生面对复杂问题的勇气和信心，培养勇于挑战的精神。
课程性质：本课程为计算机科学与技术专业的核心课程，旨在帮助学生掌握多线程编程技术，提高程序设计能力。
学生特点：学生具备一定的编程基础，熟悉基本的数据结构和算法，但对于多线程编程尚处于入门阶段。
教学要求：结合学生特点，课程设计应注重理论与实践相结合，通过案例分析和实际操作，使学生掌握多线程编程的核心知识，并能够应用于实际项目中。
同时，注重培养学生的团队协作能力和解决问题的能力。
在教学过程中，关注学生的个体差异，提供有针对性的指导，确保每位学生都能达到课程目标。
二、教学内容1. 多线程基本概念：线程与进程的区别，多线程的优势与挑战。
2. 多线程编程基础：线程的创建、运行、同步与销毁，线程池的原理与应用。
3. 多线程同步机制：互斥锁、条件变量、信号量等同步工具的使用。
4. 线程间通信：共享内存、消息队列、管道等通信方式。
5. 线程调度策略：时间片轮转、优先级调度等策略。
6. 多线程程序性能优化：减少线程竞争、降低锁的开销、合理设置线程数量等。
7. 多线程编程案例分析：分析实际项目中多线程的应用，总结编程技巧。
教学大纲安排：第一周：多线程基本概念，线程与进程的区别，多线程的优势与挑战。
第二周：多线程编程基础，线程的创建、运行、同步与销毁。
MySQL中的多线程与并行查询优化技巧MySQL是一种常用的关系型数据库管理系统，被广泛应用于各种规模的应用程序中。
在处理大规模数据时，MySQL的性能往往成为一个关键问题。
多线程和并行查询是两个常见的优化技巧，可用于提升MySQL的性能和吞吐量。
本文将深入探讨MySQL中的多线程与并行查询优化技巧。
一、多线程优化多线程是一种通过同时执行多个线程来提高系统性能的技术。
在MySQL中，多线程技术可以用于提高并发查询和处理能力，从而提升整体性能。
以下是一些常见的多线程优化技巧。
1. 使用线程池线程池是一种管理和复用线程的技术，它可以避免频繁创建和销毁线程的开销。
在MySQL中，使用线程池可以降低线程创建和销毁的成本，并且可以根据系统负载动态调整线程池大小以适应不同的并发需求。
2. 合理配置并发连接数在MySQL中，连接数是指同时允许的客户端连接数量。
合理配置并发连接数可以充分利用多线程，并避免过多的连接导致系统性能下降。
过高的并发连接数可能会导致线程竞争和锁争用，而过低的并发连接数则可能导致系统无法满足用户需求。
因此，需要根据应用程序的需求和硬件资源来配置合适的并发连接数。
3. 使用并行复制并行复制是指在主从复制过程中允许并行执行多个复制线程。
通过使用并行复制，可以将复制过程中的计算任务分摊到多个线程上，从而提高整体复制性能。
在MySQL 5.7及更高版本中，可以通过配置参数来启用并行复制功能。
二、并行查询优化并行查询是指将单个查询任务拆分成多个子任务，并通过同时执行这些子任务来提高查询性能。
在MySQL中，可以通过以下方式来实现并行查询优化。
1. 分区表分区表是将大表拆分成多个小表的技术。
通过将数据按照某种规则（如范围、列表等）进行分区，可以将查询任务分配到不同的分区上并行执行，从而提高查询性能。
2. 并行查询在MySQL 5.7及更高版本中，引入了并行查询功能。
通过将查询任务拆分成多个并行执行的子任务，可以利用多核处理器的优势并发执行查询操作，从而提高整体查询性能。
利用多线程提高图像处理性能随着计算机技术的不断发展，图像处理已经成为了我们日常生活中不可或缺的一部分。
在图像处理过程中，提高处理性能是一个重要而又具有挑战性的问题。
而多线程技术的应用，则成为了提高图像处理性能的一种有效方式。
本文将详细探讨如何利用多线程提高图像处理性能。
一、理解多线程多线程指的是程序中包含多个独立的执行流，可以同时运行在不同的核心或者不同的处理器上，从而提高整体的处理性能。
在图像处理中，可以利用多线程实现并行处理，将图像分成若干块，并同时进行处理，从而提升图像处理的速度。
二、图像处理的多线程优化1. 图像读取和写入的多线程优化图像处理的第一步通常是读取图像数据，而图像的读取操作通常是较为耗时的。
因此，可以将图像读取的过程与图像处理过程分离，采用多线程的方式，实现并行读取多个图像。
当图像读取完毕后，再将图像数据传递给处理线程进行处理。
同样地，图像处理完毕后，也可以采用多线程的方式进行并行写入多个图像。
2. 并行处理不同区域的图像在图像处理过程中，通常可以将图像分割成多个小块，每个块都可以独立进行处理。
这样一来，就可以利用多线程的方式同时处理各个小块，从而提高整体的处理速度。
不同的处理线程可以分别处理不同的小块，或者采用任务队列的方式，根据线程的空闲情况进行任务分配。
3. 多线程处理算法复杂度较低的操作图像处理过程中，有些操作的算法复杂度较低，例如像素值的修改、颜色变换等。
对于这些操作，可以利用多线程并行处理，提高图像处理性能。
但对于算法复杂度较高的操作，多线程处理的效果可能并不明显，因此需要根据具体情况进行选择。
4. 多线程处理不同类型的图像对于一些具有相同处理需求的图像，可以将其放在同一线程中进行处理。
例如对于同一类型的图片进行滤镜处理，可以将不同图片放在同一线程中进行并行处理，从而提高整体的处理速度。
三、多线程的实现方式1. 使用多线程库常见的多线程库有OpenMP、Pthreads等。
什么情况下使用多线程
使用多线程是为了能够同时处理多个任务，提高程序的并发性和响应性。
以下是一些常见的情况下使用多线程的场景。
1.高并发：当需要同时处理大量请求时，使用多线程可以提高系统的并发能力。
例如，一个网络服务器需要同时处理多个客户端请求，每个请求可能会导致服务器执行一些耗时的操作，如读取文件或数据库查询。
在这种情况下，每个请求可以分配一个线程来处理，而不会因为其中一些请求的阻塞而导致其他请求被延迟。
3.并行计算：当需要进行大规模计算或处理复杂算法时，使用多线程可以将计算任务分配给多个处理器或内核，并行执行。
这种方式可以有效地缩短计算时间，提高程序的性能。
例如，图像处理、视频编码、科学计算等领域通常会使用多线程进行并行计算。
4.IO密集型任务：当任务涉及到大量的IO操作时，使用多线程可以充分利用CPU的空闲时间，提高程序的执行效率。
例如，文件的读取和写入、网络通信等操作都可以使用多线程来实现。
5.交互性应用程序：当需要处理用户的输入和响应时，使用多线程可以提供更好的用户体验。
例如，给定一个图形界面应用程序，用户在主线程中进行操作，而与用户界面相关的任务可以在后台线程中执行，以避免在主线程中进行耗时的操作而导致界面冻结。
然而，使用多线程也存在一些潜在的问题和挑战，例如线程之间的同步和互斥、资源竞争、死锁等。
程序员需要仔细考虑这些问题，并采取适当的措施来解决和避免这些问题。
总而言之，使用多线程可以在合适的情况下提高程序的并发性和响应性，但也需要合理使用，并针对具体的需求选择适当的线程模型和同步机制。
C++多线程（一） (2)C++多线程（二） (5)C++多线程（三） (11)C++多线程（四） (25)C++多线程（五） (35)C++多线程（六） (39)C++多线程（七） (45)C++多线程（八） (50)C++多线程（九） (58)C++多线程（十） (70)C++多线程（一）WIN 多线程API一简单实例比较简单的代码，创建10个线程，其中使第4个线程在一创建就挂起，等到其他的线程执行的差不多的时候再使第4个线程恢复执行。
#include <stdio.h>#include <stdlib.h>#include <windows.h>#define THREAD_NUM 10DWORD WINAPI PrintThreads (LPVOID);int main (){HANDLE hThread[THREAD_NUM];DWORD dwThreadID[THREAD_NUM];for (int i=0; i<THREAD_NUM; ++i){int isStartImmediate = 0;if(3 == i)isStartImmediate = CREATE_SUSPENDED;hThread[i]=CreateThread(NULL, // security attributes that should be applied to the new thread,// this is for NT. Use NULL to get the default security attributes. Use NULL for win950, // default size of 1MB can be passed by passing zero.PrintThreads, // function name:address of the function where the new thread starts.(LPVOID)i, // parameter(void pointer): pointer to the 32 bit parameter that will be passed into the threadisStartImmediate, // flags to control the creation of the thread. Passing zero starts the thread immediately.// Passing CREATE_SUSPENDED suspends the thread until the ResumeThread( ) function is called.&dwThreadID[i] // pointer to a 32-bit variable that receives the thread identifier.);if (hThread[i]){printf ("Thread launched successfully\n");}}printf("Start sleep 100, and let other thread excute\n");Sleep (100);printf("Start sleep 100, and thread 3 excute\n");ResumeThread(hThread[3]);Sleep(100);for(int i = 0; i<THREAD_NUM; ++i){if (hThread[i]){CloseHandle(hThread[i]); // You need to use this to release kernel objects when you are done using them.// If a process exits without closing the thread handle,// the operating system drops the reference counts for those objects.// But if a process frequently creates threads without closing the handles,// there could be hundreds of thread kernel objects lying around and these resource leaks can have a big hit on performance.}}return (0);}//function PrintThreadsDWORD WINAPI PrintThreads (LPVOID num){for (int i=0; i<10; i++)printf ("Thread Number is %d%d%d\n", num,num,num);return0;}二其他基本API的说明CreateThread() 调用成功返回句柄和一个id。
CloseHandle() 关闭一个打开的对象句柄，该对象句柄可以是线程句柄，也可以是进程、信号量等其他内核对象的句柄.SuspendThread(HANDLE) 允许开发人员将HANDLE指定的线程挂起，如果要挂起的线程占有共享资源，则可能导致死锁。
ResumeThread(HANDLE) 恢复指定的线程。
TerminateThread() 立即终止线程的工作，不做任何清理工作。
ExitThread() 线程函数返回时回调用次函数，所以一般我们不去显示的调用。
ExitThread是推荐使用的结束一个线程的方法，当调用该函数时，当前线程的栈被释放，然后线程终止，相对于TerminateThread函数来说，这样做能够更好地完成附加在该线程上的DLL的清除工作. 但是ExitThread()会导致线程在清处构造器/自动变量之前就终止，所以我们最好不要显示的调用ExitThread()。
C++多线程（二）C/C++ Runtime 多线程函数一简单实例（来自codeprojct：/useritems/MultithreadingTutorial.asp）主线程创建2个线程t1和t2，创建时2个线程就被挂起，后来调用ResumeThread恢复2个线程，是其开始执行，调用WaitForSingleObject等待2个线程执行完，然后推出主线程即结束进程。
/**//* file Main.cpp** This program is an adaptation of the code Rex Jaeschke showed in* Listing 1 of his Oct 2005 C/C++ User's Journal article entitled* "C++/CLI Threading: Part I". I changed it from C++/CLI (managed)* code to standard C++.** One hassle is the fact that C++ must employ a free (C) function* or a static class member function as the thread entry function.** This program must be compiled with a multi-threaded C run-time* (/MT for LIBCMT.LIB in a release build or /MTd for LIBCMTD.LIB* in a debug build).** John Kopplin 7/2006*/#include <stdio.h>#include <string> // for STL string class#include <windows.h> // for HANDLE#include <process.h> // for _beginthread()using namespace std;class ThreadX{private:int loopStart;int loopEnd;int dispFrequency;public:string threadName;ThreadX( int startValue, int endValue, int frequency ){loopStart = startValue;loopEnd = endValue;dispFrequency = frequency;}// In C++ you must employ a free (C) function or a static// class member function as the thread entry-point-function.// Furthermore, _beginthreadex() demands that the thread// entry function signature take a single (void*) and returned// an unsigned.static unsigned __stdcall ThreadStaticEntryPoint(void * pThis){ThreadX * pthX = (ThreadX*)pThis; // the tricky castpthX->ThreadEntryPoint(); // now call the true entry-point-function// A thread terminates automatically if it completes execution,// or it can terminate itself with a call to _endthread().return1; // the thread exit code}void ThreadEntryPoint(){// This is the desired entry-point-function but to get// here we have to use a 2 step procedure involving// the ThreadStaticEntryPoint() function.for (int i = loopStart; i <= loopEnd; ++i){if (i % dispFrequency == 0){printf( "%s: i = %d\n", threadName.c_str(), i );}}printf( "%s thread terminating\n", threadName.c_str() );}};int main(){// All processes get a primary thread automatically. This primary// thread can generate additional threads. In this program the// primary thread creates 2 additional threads and all 3 threads// then run simultaneously without any synchronization. No data// is shared between the threads.// We instantiate an object of the ThreadX class. Next we will// create a thread and specify that the thread is to begin executing// the function ThreadEntryPoint() on object o1. Once started,// this thread will execute until that function terminates or// until the overall process terminates.ThreadX * o1 = new ThreadX( 0, 1, 2000 );// When developing a multithreaded WIN32-based application with// Visual C++, you need to use the CRT thread functions to create// any threads that call CRT functions. Hence to create and terminate// threads, use _beginthreadex() and _endthreadex() instead of// the Win32 APIs CreateThread() and EndThread().// The multithread library LIBCMT.LIB includes the _beginthread()// and _endthread() functions. The _beginthread() function performs// initialization without which many C run-time functions will fail.// You must use _beginthread() instead of CreateThread() in C programs// built with LIBCMT.LIB if you intend to call C run-time functions.// Unlike the thread handle returned by _beginthread(), the thread handle// returned by _beginthreadex() can be used with the synchronization APIs.HANDLE hth1;unsigned uiThread1ID;hth1 = (HANDLE)_beginthreadex( NULL, // security0, // stack sizeThreadX::ThreadStaticEntryPoint,o1, // arg listCREATE_SUSPENDED, // so we can later call ResumeThread()&uiThread1ID );if ( hth1 == 0 )printf("Failed to create thread 1\n");DWORD dwExitCode;GetExitCodeThread( hth1, &dwExitCode ); // should be STILL_ACTIVE = 0x00000103 = 259printf( "initial thread 1 exit code = %u\n", dwExitCode );// The System::Threading::Thread object in C++/CLI has a "Name" property.// To create the equivalent functionality in C++ I added a public data member// named threadName.o1->threadName = "t1";ThreadX * o2 = new ThreadX( -1000000, 0, 2000 );HANDLE hth2;unsigned uiThread2ID;hth2 = (HANDLE)_beginthreadex( NULL, // security0, // stack sizeThreadX::ThreadStaticEntryPoint,o2, // arg listCREATE_SUSPENDED, // so we can later call ResumeThread()&uiThread2ID );if ( hth2 == 0 )printf("Failed to create thread 2\n");GetExitCodeThread( hth2, &dwExitCode ); // should be STILL_ACTIVE = 0x00000103 = 259printf( "initial thread 2 exit code = %u\n", dwExitCode );o2->threadName = "t2";// If we hadn't specified CREATE_SUSPENDED in the call to _beginthreadex()// we wouldn't now need to call ResumeThread().ResumeThread( hth1 ); // serves the purpose of Jaeschke's t1->Start()ResumeThread( hth2 );// In C++/CLI the process continues until the last thread exits.// That is, the thread's have independent lifetimes. Hence// Jaeschke's original code was designed to show that the primary// thread could exit and not influence the other threads.// However in C++ the process terminates when the primary thread exits// and when the process terminates all its threads are then terminated.// Hence if you comment out the following waits, the non-primary// threads will never get a chance to run.WaitForSingleObject( hth1, INFINITE );WaitForSingleObject( hth2, INFINITE );GetExitCodeThread( hth1, &dwExitCode );printf( "thread 1 exited with code %u\n", dwExitCode );GetExitCodeThread( hth2, &dwExitCode );printf( "thread 2 exited with code %u\n", dwExitCode );// The handle returned by _beginthreadex() has to be closed// by the caller of _beginthreadex().CloseHandle( hth1 );CloseHandle( hth2 );delete o1;o1 = NULL;delete o2;o2 = NULL;printf("Primary thread terminating.\n");}二解释1）如果你正在编写C/C++代码，决不应该调用CreateThread。
