深入浅出Win32多线程程序设计(二)――线程控制

简介:
作者:宋宝华  e-mail:21cnbao@21cn.com
 
 
WIN32 线程控制主要实现线程的创建、终止、挂起和恢复等操作,这些操作都依赖于 WIN32 提供的一组 API 和具体编译器的 C 运行时库函数。

1.线程函数

在启动一个线程之前,必须为线程编写一个全局的线程函数,这个线程函数接受一个 32 位的 LPVOID 作为参数,返回一个 UINT ,线程函数的结构为:
UINT ThreadFunction(LPVOID pParam)
{
  // 线程处理代码
  return0;
}
在线程处理代码部分通常包括一个死循环,该循环中先等待某事情的发生,再处理相关的工作:
while(1)
{
WaitForSingleObject(…,…);// WaitForMultipleObjects(…)
//Do something
}
一般来说, C++ 的类成员函数不能作为线程函数。这是因为在类中定义的成员函数,编译器会给其加上 this 指针。请看下列程序:
#include "windows.h"
#include <process.h>
class ExampleTask
{
public:
       void taskmain(LPVOID param);
       void StartTask();
};
 
 
void ExampleTask::taskmain(LPVOID param)
{
}
 
 
void ExampleTask::StartTask()
{
       _beginthread(taskmain,0,NULL);
}
 
 
int main(int argc, char* argv[])
{
    ExampleTask realTimeTask;
       realTimeTask.StartTask();
       return 0;
}
程序编译时出现如下错误:
error C2664: '_beginthread' : cannot convert parameter 1 from 'void (void *)' to 'void (__cdecl *)(void *)'
None of the functions with this name in scope match the target type
再看下列程序:
#include "windows.h"
#include <process.h>
class ExampleTask
{
public:
       void taskmain(LPVOID param);
};
 
 
void ExampleTask::taskmain(LPVOID param)
{
}
 
 
int main(int argc, char* argv[])
{
   ExampleTask realTimeTask;
       _beginthread(ExampleTask::taskmain,0,NULL);
       return 0;
}
程序编译时会出错:
error C2664: '_beginthread' : cannot convert parameter 1 from 'void (void *)' to 'void (__cdecl *)(void *)'
None of the functions with this name in scope match the target type
如果一定要以类成员函数作为线程函数,通常有如下解决方案:
1 )将该成员函数声明为 static 类型,去掉 this 指针;
我们将上述二个程序改变为:
#include "windows.h"
#include <process.h>
class ExampleTask
{
public:
       void static taskmain(LPVOID param);
       void StartTask();
};
 
 
void ExampleTask::taskmain(LPVOID param)
{
}
 
 
void ExampleTask::StartTask()
{
       _beginthread(taskmain,0,NULL);
}
 
 
int main(int argc, char* argv[])
{
    ExampleTask realTimeTask;
       realTimeTask.StartTask();
       return 0;
}
#include "windows.h"
#include <process.h>
class ExampleTask
{
public:
       void static taskmain(LPVOID param);
};
 
 
void ExampleTask::taskmain(LPVOID param)
{
}
 
 
int main(int argc, char* argv[])
{
       _beginthread(ExampleTask::taskmain,0,NULL);
       return 0;
}
均编译通过。
将成员函数声明为静态虽然可以解决作为线程函数的问题,但是它带来了新的问题,那就是 static 成员函数只能访问 static 成员。解决此问题的一种途径是可以在调用类静态成员函数(线程函数)时将 this 指针作为参数传入,并在改线程函数中用强制类型转换将 this 转换成指向该类的指针,通过该指针访问非静态成员。
2 )不定义类成员函数为线程函数,而将线程函数定义为类的友元函数。这样,线程函数也可以有类成员函数同等的权限;     
我们将程序修改为:
#include "windows.h"
#include <process.h>
class ExampleTask
{
public:
       friend void taskmain(LPVOID param);
       void StartTask();
};
 
 
void taskmain(LPVOID param)
{
       ExampleTask * pTaskMain = (ExampleTask *) param;
       // 通过 pTaskMain 指针引用
      
}
 
 
void ExampleTask::StartTask()
{
       _beginthread(taskmain,0,this);
}
int main(int argc, char* argv[])
{
    ExampleTask realTimeTask;
       realTimeTask.StartTask();
       return 0;
}
3 )可以对非静态成员函数实现回调,并访问非静态成员,此法涉及到一些高级技巧,在此不再详述。

2.创建线程

进程的主线程由操作系统自动生成, Win32 提供了 CreateThread API 来完成用户线程的创建,该 API 的原型为:
HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES lpThreadAttributes,//Pointer to a SECURITY_ATTRIBUTES structure
  SIZE_T dwStackSize, //Initial size of the stack, in bytes.
  LPTHREAD_START_ROUTINE lpStartAddress,
  LPVOID lpParameter, //Pointer to a variable to be passed to the thread
  DWORD dwCreationFlags, //Flags that control the creation of the thread
  LPDWORD lpThreadId //Pointer to a variable that receives the thread identifier
);
如果使用 C/C++ 语言编写多线程应用程序,一定不能使用操作系统提供的 CreateThread API ,而应该使用 C/C++ 运行时库中的 _beginthread (或 _beginthreadex ),其函数原型为:
uintptr_t _beginthread(
   void( __cdecl *start_address )( void * ), //Start address of routine that begins execution of new thread
   unsigned stack_size, //Stack size for new thread or 0.
   void *arglist //Argument list to be passed to new thread or NULL
);
uintptr_t _beginthreadex(
   void *security,//Pointer to a SECURITY_ATTRIBUTES structure
   unsigned stack_size,
   unsigned ( __stdcall *start_address )( void * ),
   void *arglist,
   unsigned initflag,//Initial state of new thread (0 for running or CREATE_SUSPENDED for suspended);
   unsigned *thrdaddr
);
_beginthread 函数与 Win32 API  中的 CreateThread 函数类似,但有如下差异:
1 )通过 _beginthread 函数我们可以利用其参数列表 arglist 将多个参数传递到线程;
2 _beginthread  函数初始化某些  C  运行时库变量,在线程中若需要使用  C  运行时库。

3.终止线程

线程的终止有如下四种方式:
1 )线程函数返回;
2 )线程自身调用 ExitThread  函数即终止自己,其原型为:
VOID ExitThread(UINT fuExitCode );
它将参数 fuExitCode 设置为线程的退出码。
注意:如果使用 C/C++ 编写代码,我们应该使用 C/C++ 运行时库函数 _endthread (_endthreadex) 终止线程,决不能使用 ExitThread
_endthread  函数对于线程内的条件终止很有用。例如,专门用于通信处理的线程若无法获取对通信端口的控制,则会退出。
3 )同一进程或其他进程的线程调用 TerminateThread 函数,其原型为:
BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);
该函数用来结束由 hThread 参数指定的线程,并把 dwExitCode 设成该线程的退出码。当某个线程不再响应时,我们可以用其他线程调用该函数来终止这个不响应的线程。
4 )包含线程的进程终止。
最好使用第 1 种方式终止线程,第 2~4 种方式都不宜采用。

4.挂起与恢复线程

当我们创建线程的时候,如果给其传入 CREATE_SUSPENDED 标志,则该线程创建后被挂起,我们应使用 ResumeThread 恢复它:
DWORD ResumeThread(HANDLE hThread);
如果 ResumeThread 函数运行成功,它将返回线程的前一个暂停计数,否则返回 0x FFFFFFFF
对于没有被挂起的线程,程序员可以调用 SuspendThread 函数强行挂起之:
DWORD SuspendThread(HANDLE hThread);
一个线程可以被挂起多次。线程可以自行暂停运行,但是不能自行恢复运行。如果一个线程被挂起 n 次,则该线程也必须被恢复 n 次才可能得以执行。

5.设置线程优先级

当一个线程被首次创建时,它的优先级等同于它所属进程的优先级。在单个进程内可以通过调用 SetThreadPriority 函数改变线程的相对优先级。一个线程的优先级是相对于其所属进程的优先级而言的。
BOOL SetThreadPriority(HANDLE hThread, int nPriority);
其中参数 hThread 是指向待修改优先级线程的句柄,线程与包含它的进程的优先级关系如下:
线程优先级  =  进程类基本优先级  +  线程相对优先级
进程类的基本优先级包括:
1 )实时: REALTIME_PRIORITY_CLASS
2 )高: HIGH _PRIORITY_CLASS
3 )高于正常: ABOVE_NORMAL_PRIORITY_CLASS
4 )正常: NORMAL _PRIORITY_CLASS
5 )低于正常: BELOW_ NORMAL _PRIORITY_CLASS
6 )空闲: IDLE_PRIORITY_CLASS
我们从 Win32 任务管理器中可以直观的看到这六个进程类优先级,如下图:
线程的相对优先级包括:
1 )空闲: THREAD_PRIORITY_IDLE
2 )最低线程: THREAD_PRIORITY_LOWEST
3 )低于正常线程: THREAD_PRIORITY_BELOW_NORMAL
4 )正常线程: THREAD_PRIORITY_ NORMAL ( 缺省 )
5 )高于正常线程: THREAD_PRIORITY_ABOVE_NORMAL
6 )最高线程: THREAD_PRIORITY_HIGHEST
7 )关键时间: THREAD_PRIOTITY_CRITICAL
下图给出了进程优先级和线程相对优先级的映射关系:
例如:
HANDLE hCurrentThread = GetCurrentThread();
// 获得该线程句柄
SetThreadPriority(hCurrentThread, THREAD_PRIORITY_LOWEST);

6.睡眠

VOID Sleep(DWORD dwMilliseconds);
该函数可使线程暂停自己的运行,直到 dwMilliseconds 毫秒过去为止。它告诉系统,自身不想在某个时间段内被调度。

7.其它重要API

获得线程优先级
一个线程被创建时,就会有一个默认的优先级,但是有时要动态地改变一个线程的优先级,有时需获得一个线程的优先级。
Int GetThreadPriority (HANDLE hThread);
如果函数执行发生错误,会返回 THREAD_PRIORITY_ERROR_RETURN 标志。如果函数成功地执行,会返回优先级标志。
获得线程退出码
BOOL WINAPI GetExitCodeThread(
    HANDLE hThread,
    LPDWORD lpExitCode
    );
如果执行成功, GetExitCodeThread 返回 TRUE ,退出码被 lpExitCode 指向内存记录;否则返回 FALSE ,我们可通过 GetLastError() 获知错误原因。如果线程尚未结束, lpExitCode 带回来的将是 STILL_ALIVE
获得 / 设置线程上下文
BOOL WINAPI GetThreadContext(
    HANDLE hThread,
    LPCONTEXT lpContext
    );
BOOL WINAPI SetThreadContext(
    HANDLE hThread,
    CONST CONTEXT *lpContext
    );
由于 GetThreadContext SetThreadContext 可以操作 CPU 内部的寄存器,因此在一些高级技巧的编程中有一定应用。譬如,调试器可利用 GetThreadContext 挂起被调试线程获取其上下文,并设置上下文中的标志寄存器中的陷阱标志位,最后通过 SetThreadContext 使设置生效来进行单步调试。

8.实例

以下程序使用 CreateThread 创建两个线程,在这两个线程中 Sleep 一段时间,主线程通过 GetExitCodeThread 来判断两个线程是否结束运行:
#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>
 
 
DWORD WINAPI ThreadFunc(LPVOID);
 
 
int main()
{
    HANDLE hThrd1;
    HANDLE hThrd2;
    DWORD exitCode1 = 0;
    DWORD exitCode2 = 0;
    DWORD threadId;
   
    hThrd1 = CreateThread(NULL, 0, ThreadFunc, (LPVOID)1, 0, &threadId );
    if (hThrd1)
        printf("Thread 1 launched\n");
 
 
    hThrd2 = CreateThread(NULL, 0, ThreadFunc, (LPVOID)2, 0, &threadId );
    if (hThrd2)
        printf("Thread 2 launched\n");
 
 
 
 
    // Keep waiting until both calls to GetExitCodeThread succeed AND
    // neither of them returns STILL_ACTIVE.
    for (;;)
    {
        printf("Press any key to exit..\n");
        getch();
 
 
        GetExitCodeThread(hThrd1, &exitCode1);
        GetExitCodeThread(hThrd2, &exitCode2);
        if ( exitCode1 == STILL_ACTIVE )
            puts("Thread 1 is still running!");
        if ( exitCode2 == STILL_ACTIVE )
            puts("Thread 2 is still running!");
        if ( exitCode1 != STILL_ACTIVE
            && exitCode2 != STILL_ACTIVE )
            break;
    }
 
 
    CloseHandle(hThrd1);
    CloseHandle(hThrd2);
 
 
    printf("Thread 1 returned %d\n", exitCode1);
    printf("Thread 2 returned %d\n", exitCode2);
 
 
    return EXIT_SUCCESS;
}
 
 
/*
 * Take the startup value, do some simple math on it,
 * and return the calculated value.
 */
DWORD WINAPI ThreadFunc(LPVOID n)
{
    Sleep((DWORD)n*1000*2);
    return (DWORD)n * 10;
}
通过下面的程序我们可以看出多线程程序运行顺序的难以预料以及 WINAPI CreateThread 函数与 C 运行时库的 _beginthread 的差别:
#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
 
 
DWORD WINAPI ThreadFunc(LPVOID);
 
 
int main()
{
  HANDLE hThrd;
  DWORD threadId;
  int i;
 
 
  for (i = 0; i < 5; i++)
  {
    hThrd = CreateThread(NULL, 0, ThreadFunc, (LPVOID)i, 0,  &threadId);
    if (hThrd)
    {
      printf("Thread launched %d\n", i);
      CloseHandle(hThrd);
    }
  }
  // Wait for the threads to complete.
  Sleep(2000);
 
 
  return EXIT_SUCCESS;
}
 
 
DWORD WINAPI ThreadFunc(LPVOID n)
{
  int i;
  for (i = 0; i < 10; i++)
    printf("%d%d%d%d%d%d%d%d\n", n, n, n, n, n, n, n, n);
  return 0;
}
运行的输出具有很大的随机性,这里摘取了几次结果的一部分(几乎每一次都不同):
          
如果我们使用标准 C 库函数而不是多线程版的运行时库,则程序可能输出“ 3333444444 ”这样的结果,而使用多线程运行时库后,则可避免这一问题。
下列程序在主线程中创建一个 SecondThread ,在 SecondThread 线程中通过自增对 Counter 计数到 1000000 ,主线程一直等待其结束:
#include <Win32.h>
#include <stdio.h>
#include <process.h>
 
 
unsigned Counter;
unsigned __stdcall SecondThreadFunc(void *pArguments)
{
  printf("In second thread...\n");
 
 
  while (Counter < 1000000)
    Counter++;
 
 
  _endthreadex(0);
  return 0;
}
 
 
int main()
{
  HANDLE hThread;
  unsigned threadID;
 
 
  printf("Creating second thread...\n");
 
 
  // Create the second thread.
  hThread = (HANDLE)_beginthreadex(NULL, 0, &SecondThreadFunc, NULL, 0, &threadID);
 
 
  // Wait until second thread terminates
  WaitForSingleObject(hThread, INFINITE);
  printf("Counter should be 1000000; it is-> %d\n", Counter);
  // Destroy the thread object.
  CloseHandle(hThread);
}

 本文转自 21cnbao 51CTO博客,原文链接:http://blog.51cto.com/21cnbao/120734,如需转载请自行联系原作者



相关文章
|
8天前
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
16天前
|
Java Spring
spring多线程实现+合理设置最大线程数和核心线程数
本文介绍了手动设置线程池时的最大线程数和核心线程数配置方法,建议根据CPU核数及程序类型(CPU密集型或IO密集型)来合理设定。对于IO密集型,核心线程数设为CPU核数的两倍;CPU密集型则设为CPU核数加一。此外,还讨论了`maxPoolSize`、`keepAliveTime`、`allowCoreThreadTimeout`和`queueCapacity`等参数的设置策略,以确保线程池高效稳定运行。
79 10
spring多线程实现+合理设置最大线程数和核心线程数
|
24天前
|
Java 数据库 Android开发
一个Android App最少有几个线程?实现多线程的方式有哪些?
本文介绍了Android多线程编程的重要性及其实现方法,涵盖了基本概念、常见线程类型(如主线程、工作线程)以及多种多线程实现方式(如`Thread`、`HandlerThread`、`Executors`、Kotlin协程等)。通过合理的多线程管理,可大幅提升应用性能和用户体验。
43 15
一个Android App最少有几个线程?实现多线程的方式有哪些?
|
6天前
|
NoSQL 网络协议 Unix
1)Redis 属于单线程还是多线程?不同版本之间有什么区别?
1)Redis 属于单线程还是多线程?不同版本之间有什么区别?
18 1
|
9天前
|
Python
5-5|python开启多线程入口必须在main,从python线程(而不是main线程)启动pyQt线程有什么坏处?...
5-5|python开启多线程入口必须在main,从python线程(而不是main线程)启动pyQt线程有什么坏处?...
|
26天前
|
Java 数据库 Android开发
一个Android App最少有几个线程?实现多线程的方式有哪些?
本文介绍了Android应用开发中的多线程编程,涵盖基本概念、常见实现方式及最佳实践。主要内容包括主线程与工作线程的作用、多线程的多种实现方法(如 `Thread`、`HandlerThread`、`Executors` 和 Kotlin 协程),以及如何避免内存泄漏和合理使用线程池。通过有效的多线程管理,可以显著提升应用性能和用户体验。
38 10
|
8天前
|
Java
COMATE插件实现使用线程池高级并发模型简化多线程编程
本文介绍了COMATE插件的使用,该插件通过线程池实现高级并发模型,简化了多线程编程的过程,并提供了生成结果和代码参考。
|
2月前
|
存储 监控 Java
Java多线程优化:提高线程池性能的技巧与实践
Java多线程优化:提高线程池性能的技巧与实践
64 1
|
1月前
|
存储 Ubuntu Linux
C语言 多线程编程(1) 初识线程和条件变量
本文档详细介绍了多线程的概念、相关命令及线程的操作方法。首先解释了线程的定义及其与进程的关系,接着对比了线程与进程的区别。随后介绍了如何在 Linux 系统中使用 `pidstat`、`top` 和 `ps` 命令查看线程信息。文档还探讨了多进程和多线程模式各自的优缺点及适用场景,并详细讲解了如何使用 POSIX 线程库创建、退出、等待和取消线程。此外,还介绍了线程分离的概念和方法,并提供了多个示例代码帮助理解。最后,深入探讨了线程间的通讯机制、互斥锁和条件变量的使用,通过具体示例展示了如何实现生产者与消费者的同步模型。
下一篇
无影云桌面