精华内容
下载资源
问答
  • 创建进程线程的函数
    千次阅读
    2020-06-15 09:23:25

    进程和线程是我们制作游戏外挂的重点,设计多线程,进程的控制。

    API之进程和线程函数

    CancelWaitableTimer 这个函数用于取消一个可以等待下去的计时器操作 
    CallNamedPipe 这个函数由一个希望通过管道通信的一个客户进程调用 
    ConnectNamedPipe 指示一台服务器等待下去,直至客户机同一个命名管道连接 
    CreateEvent 创建一个事件对象 
    CreateMailslot 创建一个邮路。返回的句柄由邮路服务器使用(收件人) 
    CreateMutex 创建一个互斥体(MUTEX) 
    CreateNamedPipe 创建一个命名管道。返回的句柄由管道的服务器端使用 
    CreatePipe 创建一个匿名管道 
    CreateProcess 创建一个新进程(比如执行一个程序) 
    CreateSemaphore 创建一个新的信号机 
    CreateWaitableTimer 创建一个可等待的计时器对象 
    DisconnectNamedPipe 断开一个客户与一个命名管道的连接 
    DuplicateHandle 在指出一个现有系统对象当前句柄的情况下,为那个对象创建一个新句柄 
    ExitProcess 中止一个进程 
    FindCloseChangeNotification 关闭一个改动通知对象 
    FindExecutable 查找与一个指定文件关联在一起的程序的文件名 
    FindFirstChangeNotification 创建一个文件通知对象。该对象用于监视文件系统发生的变化 
    FindNextChangeNotification 重设一个文件改变通知对象,令其继续监视下一次变化 
    FreeLibrary 释放指定的动态链接库 
    GetCurrentProcess 获取当前进程的一个伪句柄 
    GetCurrentProcessId 获取当前进程一个唯一的标识符 
    GetCurrentThread 获取当前线程的一个伪句柄 
    GetCurrentThreadId 获取当前线程一个唯一的线程标识符 
    GetExitCodeProces 获取一个已中断进程的退出代码 
    GetExitCodeThread 获取一个已中止线程的退出代码 
    GetHandleInformation 获取与一个系统对象句柄有关的信息 
    GetMailslotInfo 获取与一个邮路有关的信息 
    GetModuleFileName 获取一个已装载模板的完整路径名称 
    GetModuleHandle 获取一个应用程序或动态链接库的模块句柄 
    GetPriorityClass 获取特定进程的优先级别 
    GetProcessShutdownParameters 调查系统关闭时一个指定的进程相对于其它进程的关闭早迟情况 
    GetProcessTimes 获取与一个进程的经过时间有关的信息 
    GetProcessWorkingSetSize 了解一个应用程序在运行过程中实际向它交付了多大容量的内存 
    GetSartupInfo 获取一个进程的启动信息 
    GetThreadPriority 获取特定线程的优先级别 
    GetTheardTimes 获取与一个线程的经过时间有关的信息 
    GetWindowThreadProcessId 获取与指定窗口关联在一起的一个进程和线程标识符 
    LoadLibrary 载入指定的动态链接库,并将它映射到当前进程使用的地址空间 
    LoadLibraryEx 装载指定的动态链接库,并为当前进程把它映射到地址空间 
    LoadModule 载入一个Windows应用程序,并在指定的环境中运行 
    MsgWaitForMultipleObjects 等侯单个对象或一系列对象发出信号。如返回条件已经满足,则立即返回 
    SetPriorityClass 设置一个进程的优先级别 
    SetProcessShutdownParameters 在系统关闭期间,为指定进程设置他相对于其它程序的关闭顺序 
    SetProcessWorkingSetSize 设置操作系统实际划分给进程使用的内存容量 
    SetThreadPriority 设定线程的优先级别 
    ShellExecute 查找与指定文件关联在一起的程序的文件名 
    TerminateProcess 结束一个进程 
    WinExec 运行指定的程序

    源文:易语言 API之进程和线程函数

    更多相关内容
  • Windows-API函数大全(API之进程线程函数)-附件资源
  • Linux中进程线程使用的几个函数

    千次阅读 2018-05-24 22:59:30
    1.linux进程相关函数(1)获取当前进程号 pid_t getpid(void) 头文件:sys/types.h、unistd.h 该函数成功返回当前ID,该函数always successful(2)获取父进程号 pid_t getppid(void) 头文件:sys/types.h、...

    1.linux进程相关函数

    (1)获取当前进程号

            pid_t getpid(void)

            头文件:sys/types.h、unistd.h

            该函数成功返回当前ID,该函数always successful

    (2)获取父进程号

            pid_t getppid(void)

            头文件:sys/types.h、unistd.h

            always successful

    (3)进程创建

           (3-1) pid_t fork(void)

            头文件:sys/types.h、unistd.h

            功能:在当前进程中创建一个进程,与父进程共享代码段,复制父进程的堆栈段和数据段,子进程复制父进程,然后执行fork()后的代码。向父进程返回创建进程的进程号,在子进程中返回0。

            返回值:fork返回给父进程所创建进程的进程号,然后返回创建成功标志值为0,失败-1或者errno

            (3-2)pid_t fork(void)

            头文件:sys/types.h、unistd.h

            功能:和fork(父子进程的执行次序不确定)类似,但vfork保证了子进程先执行,子进程退出后父进程才执行,而且在创建时不像fork分配一片新的进程空间,而是在父进程的空间里执行。

    (4)进程的退出

            void exit(int value) //value为0代表正常退出,非0(一般1或-1)表示非正常退出,一般会有对应情况

            父进程:exit(0)和return(0)

            子进程:exit(0)

    return和exit的区别是exit停止进程并且value表示进程退出状态,return是函数返回的标志可以返回多种数据类型

    exit()(库函数;sdtlib.h)和_exit(系统调用;unistd.h):终止进程以后,_exit()缓冲区不被保存,exit()缓冲区被保存

    exit函数作用:进程停止运行之前,检查文件打开情况,把文件缓冲区内容写回文件。,清除其使用的内存空间,并清除其在内核中的各种数据结构。

    【知识科普】:(1)缓冲I/O,对应每一个打开的文件,在内存中都有一片缓冲区,每次读文件,连续读出若干条记录,这样在下次读文件时就可以直接从内存缓冲区读取;每次写文件写入内存缓冲区,等满足一定条件,将缓冲区内容一次性写入文件。

    (2)僵尸进程:几乎放弃所有的内存空间,没有任何执行代码,也不能被调度,仅仅在进程列表中保留一个位置,记载该进程的退出状态供其他进程收集,除此之外,僵尸进程不再占有任何内存空间

    (5)进程的等待函数

            pid_t wait(int *status)

            头文件:sys/type.h;sys/wait.h

            功能:挂起调用他(现在)的进程,直到子进程结束,然后才接着运行该进程

            返回值:成功返回终止的那个进程的id,失败返回-1

            参数:记录进程退出的状态(正常/异常退出)

            pid_t waitpid(pid_t pid ,int *status,int options)

            头文件:sys/type.h;sys/wait.h

            参数:pid >0:等待进程ID为pid的子进程

                            =0:等待同一进程组中的任何子进程

                            =-1:等待任一子进程,此时和wait一样

                            <-1:等待绝对值为pid的进程组的任一子进程

                        options 0:和wait一样,阻塞父进程等待子进程;WNOHANG:如果pid指定的子进程没有结束,则waitpid()函数立即返回0,而不是阻塞在这个函数上等待;如果结束了,则返回该子进程的进程号。

    (6)执行进程

            int execl(const char*path,const char *arg,....)

            所属库:unistd.h

            函数功能:运行可执行文件

            返回值:成功无返回值,失败返回-1或者错误信息指针

            参数:path:可执行文件路径(如liux的命令路径,如ls的路径);arg:可执行文件(既可以是二进制文件,也可以是Linux下任何可执行脚本文件)所需要的参数

            与fork()比较,保留原有进程,执行新代码。占用原有进程的巢穴,将其代码段覆盖

            exec族函数:根据指定的文件名或目录名找到可执行文件,并用它来取代原调用进程的数据段、代码段和堆栈段,在执行完之后,原调用进程的内容除了进程号外,其他全部被新程序的内容替换了。

    用处:a. 当进程认为自己不能再为系统和用户做出任何贡献时,就可以调用任何exec 函数族让自己重生。

    b. 如果一个进程想执行另一个程序,那么它就可以调用fork函数新建一个进程,然后调用任何一个exec函数使子进程重生。

    (7)system(调用/bin/sh来执行参数指定的命令,file父进程为bash,即linux的sh命令解析器)

            int system(const char *file)

            头文件:stdlib.h

            功能:fork+execl,fork建立子进程,用excel函数根据参数file找到并执行可执行文件

            返回值:对于fork失败,system()函数返回-1。 如果exec执行成功,也即command顺利执行完毕,则返回command通过exit或return返回的值.如果exec执行失败,也即command没有顺利执行,比如被信号中断,或者command命令根本不存在,system()函数返回127. 如果command为NULL,则system()函数返回非0值,一般为1.

    system和execl相比,system不再是当前的进程

    (8)进程挂起

            unsigned int sleep(unsigned int seconds)

            头文件:#include <unistd.h>

            函数说明:sleep()会令目前的进程暂停, 直到达到参数seconds 所指定的时间, 或是被信号所中断。sleep结束后被挂起的进程不一定马上执行,还是切换到就绪态等待CPU

            返回值:若进程/线程挂起到参数所指定的时间则返回0,若有信号中断则返回剩余秒数。

            void usleep(unsigned long usec)//单位为us

            由于linux调度是毫秒级,所以usleep不太准

    2.linux线程相关函数

    (1)线程创建函数

    #include <pthread.h>
    int pthread_create(pthread_t *restrict tidp, //是一个传出参数,用于保存成功创建线程之后对应的线程id
        const pthread_attr_t *restrict attr, //线程属性,默认为NULL,如果想使用具体的属性也可以修改具体的参数
                 void *(*start_rtn)(void), //指向创建线程所执行函数的入口地址,函数执行完毕,则线程结束。
                      void *restrict arg); //线程主函数执行期间所使用的参数

    ret-成功返回0 失败返回错误编号。注意:由于创建线程函数是一个库函数,不是系统调用函数。所以其错误信息不能用perror()进行打印,采用strerror(错误号)可以将错误信息打印出来。其中strerror函数是包含#include<string.h>之中的一个库函数。

    (2)获取线程自身ID

    include <pthread.h>
    pthread_t pthread_self(void);

    ret-调用线程的线程ID,返回值为一个无符号长整型

    说明:线程id是在一个进程中的内部标识,但不同进程中的线程id可能相同。

             进程与进程中线程的代码运行按时间先后顺序

    (3)比较两个线程ID

    #include <pthread.h>
    int pthread_equal(pthread_t tid1, pthread_t tid2);

    ret-若相等则返回非0值,否则返回0值

    (4)单个线程退出

    #include <pthread.h>

    void pthread_exit(void *rval_ptr);//rval_ptr是一个无类型指针,与传递给启动例程的单个参数类似,进程中的其他线程可以通过调用pthread_join函数访问到这个指针;

    返回值:无返回值,跟进程一样,线程结束的时候无法返回到它的调用者(自身)

    (5)等待线程结束函数

    #include <pthread.h>
    int pthread_join(pthread_t thread, void **rval_ptr);//thread:被等待的线程标识符ID;rval_ptr:一个用户定义的指针,它可以用来存储被等待线程的返回值 

    ret-成功返回0 否则返回错误编号

          调用线程一直阻塞,直到指定的线程调用pthread_exit,从启动例程中返回或者被取消;如果线程(指调用的在等待的pthread)只是从调用它等待它的例程中返回,rval_ptr将包含返回码;如果线程被取消,由rval_ptr指定的内存单元就设置为PTHREAD_CANCELED.如果线程已经处于分离状态,pthread_t就会调用失败,返回EINVAL。如果对线程的返回值不感兴趣,可以吧rval_prt设置为NULL。这种情况下,调用pthread_join将等待线程终止,但不获取线程的终止状态。

            分离状态说明:在默认情况下线程是非分离状态的,这种情况下,原有的线程等待创建的线程结束。只有当pthread_join()函数返回时,创建的线程才算终止,才能释放自己占用的系统资源。而分离线程不是这样子的,它没有被其他的线程所等待,自己运行结束了,线程也就终止了,马上释放系统资源。

    说明:这个函数是一个线程阻塞的函数,调用它的函数将一直等待到被等待的线程结束为止,当函数返回时,被等待线程的资源被收回 

    (6)线程取消

    #include <pthread.h>
    int pthread_cancel(pthread_t tid);// thread 要取消线程的标识符ID

    ret-成功返回0 失败返回错误码

    功能:取消某个线程的执行。调用了参数是PTHREAD_CANCELD的pthread_exit函数,但是,线程可以选择或者忽略、或者立即终止、或者继续运行至Cancelation-point(取消点:会引起阻塞的系 统调用)。函数并不等待线程终止,它仅仅是提出请求。线程接收到CANCEL信号的缺省处理(即pthread_create()创建线程的缺省状态)是继续运行至取消点才会退出。

    (7)分离释放线程(由系统回收线程所占资源)

    #include <pthread.h>

    int pthread_detach(pthread_t thread); // thread 要释放线程的标识符ID

    返回值:若是成功返回0,否则返回错误的编号 

    说 明:linux线程执行和windows不同,pthread有两种状态joinable状态和unjoinable状态。一个线程默认的状态是joinable,如果线程是joinable状态,当线程函数自己返回退出时或pthread_exit时都不会释放线程所占用堆栈和线程描述符(总计8K多)。只有当你调用了pthread_join之后这些资源才会被释放。若是unjoinable状态的线程,这些资源在线程函数退出时或pthread_exit时自动会被释放。unjoinable属性可以在pthread_create时指定,或在线程创建后在线程中pthread_detach自己, 如:pthread_detach(pthread_self()),将状态改为unjoinable状态,确保资源的释放。如果线程状态为joinable,需要在之后适时调用pthread_join。

    (8)线程清理处理函数

    #include <pthread.h>
    void pthread_cleanup_push(void(*rtn)(void*), void *arg);//rtn为清理函数,arg为清理函数的参数

    void pthread_cleanup_pop(int execute); //调用删除上次push的清理程序

    当线程执行以下动作时调用清理函数:a. 调用pthread_exit;b. 想用取消请求;c. 用非零的execute参数调用pthread_cleanup_pop;如果execute=0则函数不被调用;
    注意正常从线程返回(return)的时候,不会调用该清理函数;


    展开全文
  • CreateThread创建线程函数详细讲解

    千次阅读 2019-10-31 10:07:14
    CreateThread函数创建一个要在调用进程的地址空间中执行的线程。(MSDN讲解如下) 处理CreateThread ( LPSECURITY_ATTRIBUTES lpThreadAttributes, //指向安全属性的指针 dwStackSize, //初始线程堆栈大小 说明:...

    CreateThread
    CreateThread函数创建一个要在调用进程的地址空间中执行的线程。(MSDN讲解如下)

    处理CreateThread (
    LPSECURITY_ATTRIBUTES lpThreadAttributes, //指向安全属性的指针
    dwStackSize, //初始线程堆栈大小
    说明:LPTHREAD_START_ROUTINE lpStartAddress, //指向线程函数的指针。-
    LPVOID lpParameter, //新线程的参数
    DWORD dwCreationFlags, // create flags
    接收线程ID的指针
    );
    

    实例: m_hSendThread = CreateThread(NULL,0,SendThread,this,0,&m_dwSendThreadID);
    倒数第二个参数为0表示线程创建后立即运行
    最后一个参数不为空,表示运行后有返回值

    参数
    lpThreadAttributes
    指向SECURITY_ATTRIBUTES结构的指针,该结构决定子进程是否可以继承返回的句柄。如果lpThreadAttributes为空,则不能继承句柄。
    结构的lpSecurityDescriptor成员为新线程指定一个安全描述符。如果lpThreadAttributes为空,线程将获得一个默认的安全描述符。

    dwStackSize
    指定堆栈的初始提交大小,以字节为单位。系统将这个值舍入到最近的页面。如果此值为零,或者小于默认的提交大小,则默认情况下使用与调用线程相同的大小。有关更多信息,请参见线程堆栈大小。
    lpStartAddress
    指向由线程执行的类型为lpthread_start_例程的应用程序定义的函数的指针,并表示线程的起始地址。有关thread函数的更多信息,请参见ThreadProc。
    lpParameter
    指定传递给线程的单个32位参数值。
    dwCreationFlags
    指定控制线程创建的附加标志。如果指定了CREATE_SUSPENDED标志,则线程将以挂起状态创建,并且在调用ResumeThread函数之前不会运行。如果该值为零,则线程在创建后立即运行。此时,不支持其他值。
    lpThreadId
    指向接收线程标识符的32位变量的指针。
    如果该参数为空,则不返回线程标识符。

    Windows 95和Windows 98:此参数可能不为空。

    返回值
    如果函数成功,则返回新线程的句柄。

    如果函数失败,返回值为NULL。要获取扩展的错误信息,请调用GetLastError。

    只有在32位程序的上下文中调用CreateThread时才会成功。当16位程序调用一个32位DLL时,该DLL不能创建额外的线程。

    讲话
    使用THREAD_ALL_ACCESS创建新线程句柄。如果没有提供安全描述符,则可以在需要线程对象句柄的任何函数中使用该句柄。当提供安全描述符时,将在授予访问权之前对句柄的所有后续使用执行访问检查。如果访问检查拒绝访问,请求进程就不能使用句柄来访问线程。

    线程执行从lpStartAddress参数指定的函数开始。如果此函数返回,则使用DWORD返回值终止对ExitThread函数的隐式调用中的线程。使用GetExitCodeThread函数获取线程的返回值。

    即使lpStartAddress指向数据、代码或不可访问,CreateThread函数也可能成功。如果线程运行时起始地址无效,则发生异常,线程终止。由于无效的开始地址而导致的线程终止将作为线程进程的错误退出处理。这种行为类似于CreateProcess的异步本质,即使它引用无效或缺少动态链接库(dll),也会创建进程。

    线程的优先级是THREAD_PRIORITY_NORMAL。使用GetThreadPriority和SetThreadPriority函数来获取和设置线程的优先级值。

    当一个线程终止时,线程对象达到一个有信号状态,满足任何正在等待该对象的线程。

    线程对象一直保留在系统中,直到线程终止,并且通过调用CloseHandle关闭了对它的所有句柄。

    ExitProcess、ExitThread、CreateThread、CreateRemoteThread函数和正在启动的进程(作为CreateProcess调用的结果)在一个进程内彼此序列化。在地址空间中一次只能发生一个事件。这意味着以下限制仍然有效:

    在进程启动和DLL初始化过程中,可以创建新线程,但是在进程完成DLL初始化之前,它们不会开始执行。
    一个进程中一次只能有一个线程处于DLL初始化或分离例程中。
    ExitProcess直到没有线程在其DLL初始化或分离例程时才返回。
    使用C运行库函数的线程应该使用beginthread和endt

    展开全文
  • 使用CreateThread函数创建线程

    千次阅读 2019-03-21 16:33:38
    作者:Ezioooooo 来源:CSDN ...版权声明:本文为博主原创文章,转载请附上博文...一个进程可以拥有多个线程,但是一个线程必须有一个进程线程自己不拥有系统资源,只有运行所必须的一些数据结构,但它可以与同属于...

    作者:Ezioooooo
    来源:CSDN
    原文:https://blog.csdn.net/u012877472/article/details/49721653
    版权声明:本文为博主原创文章,转载请附上博文链接!


    线程是进程中的一个实体,是被系统独立调度和分派的基本单位。一个进程可以拥有多个线程,但是一个线程必须有一个进程。线程自己不拥有系统资源,只有运行所必须的一些数据结构,但它可以与同属于一个进程的其它线程共享进程所拥有的全部资源,同一个进程中的多个线程可以并发执行。

    在C/C++中可以通过CreateThread函数在进程中创建线程,函数的具体格式如下:

    HANDLE CreateThread(
                        LPSECURITY_ATTRIBUTES lpThreadAttributes,
                        DWORD dwStackSize,
                        LPTHREAD_START_ROUTINE lpStartAddress,
                        LPVOID lpParameter,
                        DWORD dwCreationFlags,
                        LPDWORD lpThreadID
                       );
    

    参数的含义如下:
    lpThreadAttrivutes:指向SECURITY_ATTRIBUTES的指针,用于定义新线程的安全属性,一般设置成NULL;

    dwStackSize:分配以字节数表示的线程堆栈的大小,默认值是0;

    lpStartAddress:指向一个线程函数地址。每个线程都有自己的线程函数,线程函数是线程具体的执行代码;

    lpParameter:传递给线程函数的参数;

    dwCreationFlags:表示创建线程的运行状态,其中CREATE_SUSPEND表示挂起当前创建的线程,而0表示立即执行当前创建的进程;

    lpThreadID:返回新创建的线程的ID编号;

    如果函数调用成功,则返回新线程的句柄,调用WaitForSingleObject函数等待所创建线程的运行结束。函数的格式如下:

    DWORD WaitForSingleObject(
                              HANDLE hHandle,
                              DWORD dwMilliseconds
                             );
    

    参数的含义如下:
    hHandle:指定对象或时间的句柄;

    dwMilliseconds:等待时间,以毫秒为单位,当超过等待时间时,此函数返回。如果参数设置为0,则该函数立即返回;如果设置成INFINITE,则该函数直到有信号才返回。

    一般情况下需要创建多个线程来提高程序的执行效率,但是多个线程同时运行的时候可能调用线程函数,在多个线程同时对一个内存地址进行写入操作,由于CPU时间调度的问题,写入的数据会被多次覆盖,所以要使线程同步。

    就是说,当有一个线程对文件进行操作时,其它线程只能等待。可以通过临界区对象实现线程同步。临界区对象是定义在数据段中的一个CRITICAL_SECTION结构,Windows内部使用这个结构记录一些信息,确保同一时间只有一个线程访问改数据段中的数据。

    使用临界区的步骤如下:

    (1)初始化一个CRITICAL_SECTION结构;在使用临界区对象之前,需要定义全局CRITICAL_SECTION变量,在调用CreateThread函数前调用InitializeCriticalSection函数初始化临界区对象;

    (2)申请进入一个临界区;在线程函数中要对保护的数据进行操作前,可以通过调用EnterCriticalSection函数申请进入临界区。由于同一时间内只能有一个线程进入临界区,所以在申请的时候如果有一个线程已经进入临界区,则该函数就会一直等到那个线程执行完临界区代码;

    (3)离开临界区;当执行完临界区代码后,需要调用LeaveCriticalSection函数离开临界区;

    (4)删除临界区;当不需要临界区时调用DeleteCriticalSection函数将临界区对象删除;

    下面的代码创建了5个线程,每个线程在文件中写入10000个“hello”:

    #include <stdio.h>
    #include <windows.h>
    HANDLE hFile;
    CRITICAL_SECTION cs;//定义临界区全局变量
    //线程函数:在文件中写入10000个hello
    DWORD WINAPI Thread(LPVOID lpParam)
    {
        int n = (int)lpParam;
        DWORD dwWrite;
        for (int i = 0;i < 10000;i++)
        {
            //进入临界区
            EnterCriticalSection(&cs);
            char data[512] = "hello\r\n";
            //写文件
            WriteFile(hFile, data, strlen(data), &dwWrite, NULL);
            //离开临界区
            LeaveCriticalSection(&cs);
        }
        printf("Thread #%d returned successfully\n", n);
        return 0;
    }
    int main()
    {
        char *filename = "hack.txt";
        WCHAR name[20] = { 0 };
        MultiByteToWideChar(CP_ACP, 0, filename, strlen(filename) + 1, name, sizeof(name) / sizeof(name[0]));
        //创建文件
        hFile = CreateFile(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hFile == INVALID_HANDLE_VALUE)
        {
            printf("CreateFile error.\n");
            return 0;
        }
        DWORD ThreadID;
        HANDLE hThread[5];
        //初始化临界区
        InitializeCriticalSection(&cs);
        for (int i = 0;i < 5;i++)
        {
            //创建线程,并调用Thread写文件
            hThread[i] = CreateThread(NULL, 0, Thread, (LPVOID)(i + 1), 0, &ThreadID);
            printf("Thread #%d has been created successfully.\n", i + 1);
        }
        //等待所有进程结束
        WaitForMultipleObjects(5, hThread, TRUE, INFINITE);
        //删除临界区
        DeleteCriticalSection(&cs);
        //关闭文件句柄
        CloseHandle(hFile);
        return 0;
    }
    

    结果如图:
    在这里插入图片描述


    以上为原文,对代码示例做了些许改动:

    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    HANDLE hFile;
    CRITICAL_SECTION cs;//定义临界区全局变量
    //线程函数:在文件中写入10000个hello
    DWORD WINAPI Thread(LPVOID lpParam)
    {
    	int n = (int)lpParam;
    	DWORD dwWrite;
    	for (int i = 0; i < 10000; i++)
    	{
    		//进入临界区
    		EnterCriticalSection(&cs);
    		char data[512] = "hello\r\n";
    		//写文件
    		WriteFile(hFile, data, strlen(data), &dwWrite, NULL);
    		//离开临界区
    		LeaveCriticalSection(&cs);
    	}
    	printf("Thread #%d returned successfully\n", n);
    	return 0;
    }
    int main()
    {
    	char filename[10] = "hack.txt";
    	WCHAR name[20] = { 0 };
    	MultiByteToWideChar(CP_ACP, 0, filename, strlen(filename) + 1, name, sizeof(name) / sizeof(name[0]));
    	//创建文件
    	hFile = CreateFile((LPCSTR)name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    	if (hFile == INVALID_HANDLE_VALUE)
    	{
    		printf("CreateFile error.\n");
    		return 0;
    	}
    	DWORD ThreadID;
    	HANDLE hThread[5];
    	//初始化临界区
    	InitializeCriticalSection(&cs);
    	for (int i = 0; i < 5; i++)
    	{
    		//创建线程,并调用Thread写文件
    		hThread[i] = CreateThread(NULL, 0, Thread, (LPVOID)(i + 1), 0, &ThreadID);
    		printf("Thread #%d has been created successfully.\n", i + 1);
    	}
    	//等待所有进程结束
    	WaitForMultipleObjects(5, hThread, TRUE, INFINITE);
    	//删除临界区
    	DeleteCriticalSection(&cs);
    	//关闭文件句柄
    	CloseHandle(hFile);
    	system("pause");
    	return 0;
    }
    
    展开全文
  •  系统调用函数fork()是创建一个新进程的方式,当然vfork()也可以创建进程,但是实际上其还是调用了fork()函数。fork()函数是Linux系统中一个比较特殊的函数,其一次调用会有两个返回值,下面是fork()函数的声明: ...
  • 前面章节中,我们通过调用 pthread_create() 函数成功创建了多个线程,本节就给大家详细讲解 pthread_create() 函数的用法。 pthread_create() 函数声明在<pthread.h>头文件中,语法格式如下: int pthread_...
  • 一、内核线程概念、 二、内核线程、普通进程、用户线程、 三、内核线程、普通进程区别、 四、内核线程主要用途、 五、内核线程创建函数 kernel_thread 源码、
  • Linux系统中用户线程创建和运行方法,即pthread_create函数的用法,并举了一个简单的实例。
  • 在windows系统中创建线程函数有以下几个方法: CreadThread,AfxBeginThread,_beginthread,_beginthreadex。 一、CreateThread HANDLE WINAPI CreateThread( __in LPSECURITY_ATTRIBUTES lpThreadAttributes, ...
  • 在了解线程进程之间的区别前我们先来认识线程进程,我们从概念入手,什么是线程、什么是进程,再进行进程线程之间的不同点与相同点比较,优点与缺点进行比较理解。 进程的概念 进程(Process)就是程序的一...
  • 本实验涉及进程线程的相关知识及其创建、执行不同功能方法。 进程:资源分配的基本单位,独立执行的基本单位 线程:实质为进程内的一个执行单元、进程内的一个可调度实体、程序/进程中一个相对独立的控制流序列、...
  • C语言多线程编程-线程的基本函数

    万次阅读 多人点赞 2017-04-06 22:33:21
    线程操作函数线程属性控制函数
  • 线程(轻量级进程(LWP))概念: 线程就是一个执行流,创建一个线程就相当于在内核当中创建一个PCB(task_struct),创建出来的PCB当中的内存指针是指向进程的虚拟地址空间的。
  • C/C++线程基本函数

    千次阅读 多人点赞 2018-10-06 13:08:14
    最近在CSDN上闲逛,不知道看些什么,刷着刷着就看到了建议性锁和强制性锁,看了简单的概念后又刷到了重入锁和自旋锁。...(1)线程创建函数 intpthread_create(pthread_t *thread, const pthrea...
  • 进程线程的区别(超详细)

    万次阅读 多人点赞 2019-10-03 21:57:46
    进程线程 进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间,一个进程可以有多个线程,比如在Windows系统中,一个运行的xx.exe就是一个进程线程 进程中的一个执行任务(控制单元),负责...
  • c++用类成员函数作为线程函数

    千次阅读 2018-12-22 12:19:10
    参考:... ... 当我们创建线程的时候 线程处理函数如果是类里面的成员函数会报错,需要以下处理。 当需要利用类成员函数( MyClass::thread_func )来创建线程时,需如下...
  • 关于main函数与进程、线程退出的关系 在学习嵌入式系统的进程和线程时,有以下的疑问: 讲师说进程退出时,进程中的所有线程都会退出;但是主线程退出时,子线程是不会退出的。...创建进程时,系统会自动创
  • 内核函数 内核线程创建

    千次阅读 2018-07-12 19:31:47
    struct task_struct *kthread_create(int (*threadfn)(void *data),void *data, const char namefmt[], ...)功能:创建一个内核线程threadfn:线程运行的函数data:传递给线程函数的参数namefmt: 进程名 在task-&...
  • 调用MSVC CRT的函数_beginthread()或_beginthreadex()来创建线程。 _beginthread 参数和返回值 unsigned long _beginthread( void(_cdecl *start_address)(void *), //声明为void (*start_address)(void *)形式 ,...
  • 进程执行完return之后,实际上会调用exit()函数,该函数除了执行关闭IO等操作之外,还会执行关掉 其他子线程的操作。 <2>.主进程中执行 pthread_exit(),实际上是提前结束了main的主进程,也就无法执行后续exit...
  • C多线程编程以及线程函数

    万次阅读 多人点赞 2017-05-12 11:25:22
    线程(thread)函数结合信号量互斥锁等的应用实例。
  • 线程创建函数

    千次阅读 2016-07-14 16:52:37
    【参考1】CreateThread, AfxBeginThread,_beginthread, _beginthreadex的区别 =========================================================...1、CreateThread——Windows的API函数 2、_beginthreadex——MS对C Runti
  • 类似的枚举线程、枚举堆都是相同的方法,差别只是在创建快照时的参数不同,逐条获取快照的内容时的API函数不同而已。 枚举进程的API函数:CreateToolhelp32Snapshot()、Process32First()、Process32Next...
  • c++11用类的成员函数创建线程

    千次阅读 2018-05-10 12:17:58
    c++11用类的成员函数创建线程当需要利用类成员函数( MyClass::thread_func )来创建线程时,需如下码码:t[i] = thread(std::mem_fn(&amp;MyClass::thread_func), Object, args..); 如果thread_func为static...
  • C++多线程,多线程创建,std::thread,普通函数/成员函数/仿函数/匿名函数
  • linux下创建线程用到的函数和返回值

    千次阅读 2019-01-10 10:55:22
    (1)int pthread_create(pthread_t*thread,...功能:创建一个新的进程,并将线程加入到当前进程 返回值:线程创建函数创建成功返回0,失败返回相关错误代码; 参数: thread:指向线程标识符的指针 tattr:设置...
  • 在前面的文章中使用锁(Lock)检测线程是否释放,以及使用锁可以保证所有的线程函数都执行完毕再往下执行。如果使用Thread类处理线程就方便得多了,可以直接使用Thread对象的join方法等待线程函数执行完毕再往下执行...
  • 进程线程

    千次阅读 2021-05-08 15:49:53
    一、进程线程 进程是程序执行时的一个实例,即它是程序已经执行到何种程度的数据结构的汇集。从内核的观点看,进程的目的就是担当分配系统资源(CPU时间、内存等)的基本单位。 线程进程的一个执行流,是CPU调度...
  • 题目 Windows环境下使用CreateThread函数创建两个线程A和线程B.线程A在屏幕上用循环顺序... 先创建两个线程函数A和B,分别用for循环输出每个自然是,每输出一个自然数,让该线程挂起1秒。Windows环境下可以用Crea...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 365,701
精华内容 146,280
热门标签
关键字:

创建进程线程的函数