C语言多线程编程二

最新推荐文章于 2021-05-19 00:55:24 发布
最新推荐文章于 2021-05-19 00:55:24 发布
阅读量171 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/si-lei/p/9506292.html
版权

一. 线程通信----事件：

　　1.一对一模式：

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

//互斥解决线程冲突
//事件解决线程通信
//临界区解决线程冲突
//时间同步线程

HANDLE event[5] = { 0 };
HANDLE hd[5] = { 0 };

DWORD WINAPI Zhang(void *p)
{
    int i = 1;
    printf("张%d次说：I love you Li.\n", i);
    Sleep(1000);
    SetEvent(event[1]);

    while (++i)
    {
        WaitForSingleObject(event[0], INFINITE);    //无限等待一个信号
        printf("张%d次说：I love you Li.\n", i);
        Sleep(1000);
        //ResetEvent(event[0]);    //信号复位
        SetEvent(event[1]);
    }

    return 0;
}
DWORD WINAPI Li(void *p)
{
    int i = 0;
    while (++i)
    {
        WaitForSingleObject(event[1], INFINITE);    //无限等待一个信号
        printf("李%d次说：I love you too.\n", i);
        Sleep(1000);
        //ResetEvent(event[1]);    //信号复位
        SetEvent(event[0]);
    }

    return 0;
}

void main()
{
    //第二个参数代表：自动FALSE、手动TRUE(需要reset)
    //第三个参数信号状态
    //第四个参数标记名称
    //event[0] = CreateEvent(NULL, TRUE, FALSE, NULL);
    //event[1] = CreateEvent(NULL, TRUE, FALSE, NULL);

    event[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
    event[1] = CreateEvent(NULL, FALSE, FALSE, NULL);

    hd[0] = CreateThread(NULL, 0, Zhang, NULL, 0, NULL);
    hd[1] = CreateThread(NULL, 0, Li, NULL, 0, NULL);

    WaitForMultipleObjects(2, hd, TRUE, INFINITE);

    system("pause");
}

 　　2. 一对一中介者模式：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

//互斥解决线程冲突
//事件解决线程通信
//临界区解决线程冲突
//时间同步线程

HANDLE event[5] = { 0 };
HANDLE hd[5] = { 0 };

char str[256] = { 0 };    //全局变量,存放说的内容

DWORD WINAPI Wang(void *p)
{
    int i = 0;
    int k = 0;    //判断是哪个信号

    while (++i)
    {
        if (k == 0)
        {
            WaitForSingleObject(event[1], INFINITE);    //无限等待一个信号
            printf("媒婆读取%d次：%s\n", i,str);
            Sleep(1000);
            SetEvent(event[2]);

            k = 1;
        }
        else
        {
            WaitForSingleObject(event[3], INFINITE);    //无限等待一个信号
            printf("媒婆读取%d次：%s\n", i, str);
            Sleep(1000);
            SetEvent(event[0]);

            k = 0;
        }

    }

    return 0;
}

DWORD WINAPI Zhang(void *p)
{
    int i = 1;
    /*printf("张%d次说：I love you Li.\n", i);*/
    memset(str, '0', 256);
    sprintf(str,"张%d次说：I love you Li.\n", i);
    Sleep(1000);
    SetEvent(event[1]);

    while (++i)
    {
        WaitForSingleObject(event[0], INFINITE);    //无限等待一个信号
        /*printf("张%d次说：I love you Li.\n", i);*/
        memset(str, '0', 256);
        sprintf(str,"张%d次说：I love you Li.\n", i);
        Sleep(1000);
        //ResetEvent(event[0]);    //信号复位
        SetEvent(event[1]);
    }

    return 0;
}
DWORD WINAPI Li(void *p)
{
    int i = 0;
    while (++i)
    {
        WaitForSingleObject(event[2], INFINITE);    //无限等待一个信号
        /*printf("李%d次说：I love you too.\n", i);*/
        memset(str, '0', 256);
        sprintf(str,"李%d次说：I love you too.\n", i);
        Sleep(1000);
        //ResetEvent(event[1]);    //信号复位
        SetEvent(event[3]);
    }

    return 0;
}

void main()
{
    //第二个参数代表：自动FALSE、手动TRUE(需要reset)
    //第三个参数信号状态
    //第四个参数标记名称
    //event[0] = CreateEvent(NULL, TRUE, FALSE, NULL);
    //event[1] = CreateEvent(NULL, TRUE, FALSE, NULL);

    event[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
    event[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
    event[2] = CreateEvent(NULL, FALSE, FALSE, NULL);
    event[3] = CreateEvent(NULL, FALSE, FALSE, NULL);

    hd[0] = CreateThread(NULL, 0, Zhang, NULL, 0, NULL);
    hd[1] = CreateThread(NULL, 0, Li, NULL, 0, NULL);
    hd[2] = CreateThread(NULL, 0, Wang, NULL, 0, NULL);

    WaitForMultipleObjects(3, hd, TRUE, INFINITE);

    system("pause");
}

　　3. 一对多广播模式：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

//互斥解决线程冲突
//事件解决线程通信
//临界区解决线程冲突
//时间同步线程
HANDLE event[5] = { 0 };
HANDLE hd[10] = { 0 };

char ch[10] = { 'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' };
char str[256] = { 0 };

DWORD WINAPI ZhangGirlFriend(void *p)
{
    char *pch = p;
    printf("I am %c ZhangGirlFrend.\n", *pch);

    if (*pch == 'A')
    {
        MessageBoxA(0, "1", "1", 0);
        sprintf(str,"张女友-%c speak: xiaohaha \n", *pch);
        SetEvent(event[0]);
    }

    int i = 0;
    while (++i)
    {
        WaitForSingleObject(event[0], INFINITE);
        printf("ZhangGirlFriend-%c read %s\n", *pch, str);
        Sleep(1000);
        ResetEvent(event[0]);
    }

    return 0;
}

void main()
{
    //第二个参数代表：自动FALSE(收到一次自动清空一次)、手动TRUE(需要reset)
    //第三个参数信号状态
    //第四个参数标记名称
    event[0] = CreateEventA(NULL, TRUE, FALSE, "msg");    //一直等待消息

    for (int i = 0; i < 10; i++)
    {
        hd[i] = CreateThread(NULL, 0, ZhangGirlFriend, &ch[i], 0, NULL);
    }

    WaitForMultipleObjects(10, hd, TRUE, INFINITE);

    system("pause");
}

二. 信号量：

　　1. 信号量用作“关卡”的作用：

//信号量-->关卡的作用
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

#define id "Zhang"
#define MAX 3

//0 无限等待
DWORD WINAPI myworker(void *p)
{
    int *pint = p;
    printf("myworker%d is running...\n", *pint);

    HANDLE myhsem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, id);    //打开一个信号
    if (myhsem)
    {
        printf("myworker%d is waiting...\n", *pint);
        //初始时信号为0，为0就会死锁,信号量不减
        //不为0的情况下，信号量-1
        if (WaitForSingleObject(myhsem, INFINITE) == WAIT_OBJECT_0)    //等到了信号
        {
            printf("myworker%d is getting.\n", *pint);
            Sleep(3000);

            printf("myworker%d is leaving.\n", *pint);
            ReleaseSemaphore(myhsem, 1, NULL);//释放资源 +1
            CloseHandle(myhsem);//执行完成退出
        }
    }

    return 1;
}

void main()
{
    //创建信号对象
    HANDLE hSEM = CreateSemaphore(NULL, 0, MAX, id);//开辟一个信号，最大计数是3


    int a[10] = { 0,1,2,3,4,5,6,7,8,9 };

    HANDLE hd[10] = { 0 };
    for (int i = 0; i < 10; i++)
    {
        hd[i] = CreateThread(NULL, 0, myworker, a + i, 0, NULL);    //创建10个线程
    }
    Sleep(5000);


    printf("激活线程.\n");
    ReleaseSemaphore(hSEM, MAX, NULL);//最多一次放过3个 +3

    WaitForMultipleObjects(10, hd, TRUE, INFINITE);

    CloseHandle(hSEM);

    system("pause");
}

　　2. 信号量实现互斥：

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

int num = 0;

//互斥量，只能让一个线程运行，其他休眠
//信号量，可以让多个线程运行，其他线程休眠
//临界区，只能让一个线程运行，其他休眠
//原子操作，操作速度最快
//事件也可以实现互斥
DWORD WINAPI add(void *p)
{
    HANDLE myhsem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "Hello");    
    if (myhsem)
    {

        if (WaitForSingleObject(myhsem, INFINITE) == WAIT_OBJECT_0)    //等到了信号
        {
            for (int i = 0; i < 10000; i++)
            {
                num++;
            }

            ReleaseSemaphore(myhsem, 1, NULL);//释放资源 +1
            CloseHandle(myhsem);//执行完成退出
        }
    }
    else
    {
        printf("信号量获取失败.\n");
    }

    return 1;
}

void main()
{
    HANDLE hSEM = CreateSemaphore(NULL, 0, 1, "Hello");

    HANDLE hd[64] = { 0 };
    for (int i = 0; i < 64; i++)
    {
        hd[i] = CreateThread(NULL, 0, add, NULL, 0, NULL);    //创建64个线程
    }
    Sleep(2000);

    printf("激活线程.\n");
    ReleaseSemaphore(hSEM, 1, NULL);    //一次放过一个

    WaitForMultipleObjects(64, hd, TRUE, INFINITE);

    printf("%d\n", num);

    CloseHandle(hSEM);

    system("pause");
}

三. 互斥锁：

　　相关函数如下：

　　　　第一个 InitializeSRWLock
　　　　函数功能：初始化读写锁
　　　　函数原型：VOID InitializeSRWLock(PSRWLOCK SRWLock);
　　　　函数说明：初始化（没有删除或销毁SRWLOCK的函数，系统会自动清理）


　　　　第二个 AcquireSRWLockExclusive
　　　　函数功能：写入者线程申请写资源。
　　　　函数原型：VOID AcquireSRWLockExclusive(PSRWLOCK SRWLock);

 

　　　　第三个 ReleaseSRWLockExclusive
　　　　函数功能：写入者线程写资源完毕，释放对资源的占用。
　　　　函数原型：VOID ReleaseSRWLockExclusive(PSRWLOCK SRWLock);

　　　　第四个 AcquireSRWLockShared
　　　　函数功能：读取者线程申请读资源。
　　　　函数原型：VOID AcquireSRWLockShared(PSRWLOCK SRWLock);

　　　　第五个 ReleaseSRWLockShared
　　　　函数功能：读取者线程结束读取资源，释放对资源的占用。
　　　　函数原型：VOID ReleaseSRWLockShared(PSRWLOCK SRWLock);

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

int num = 6400000;
SRWLOCK g_lock;    

//注意一个线程仅能锁定资源一次，不能多次锁定资源。
DWORD WINAPI read(void *p)
{
    AcquireSRWLockShared(&g_lock);    //读取期间锁定数据，数据无法被修改

    int i = 0;
    while (1)
    {
        Sleep(1000);
        printf("第%d秒num=%d\n", i, num);

        if (i == 10)
        {
            break;
        }

        i++;
    }

    ReleaseSRWLockShared(&g_lock);

    return 1;
}


//改变一个变量的时候需要锁定
DWORD WINAPI write(void *p)
{
    AcquireSRWLockExclusive(&g_lock);    //锁定写入
    printf("开始写入...\n");
    for (int i = 0; i < 100000; i++)
    {
        num--;
        //Sleep(10);
    }
    ReleaseSRWLockExclusive(&g_lock);
    printf("结束写入...\n");
    return 1;
}

void main()
{
    InitializeSRWLock(&g_lock);    //初始化互斥锁

    CreateThread(NULL, 0, read, NULL, 0, NULL);

    HANDLE hd[64];
    for (int i = 0; i < 64; i++)
    {
        hd[i] = CreateThread(NULL, 0, write, NULL, 0, NULL);
    }
    WaitForMultipleObjects(64, hd, TRUE, INFINITE);

    printf("last=%d\n", num);

    system("pause");
}

 四. 跨进程通信：

1. 信号量mutex 跨进程通信：

　　文件mutex1.c :

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

char name[100] = "Zhang love Li";

void main()
{
    HANDLE mutex = OpenMutexA(MUTEX_ALL_ACCESS, TRUE, name);
    if (mutex == NULL)
    {
        printf("打开失败！\n");
        system("pause");
        return;
    }
    printf("等待------\n");

    DWORD res = WaitForSingleObject(mutex, 10000);
    switch (res)
    {
    case WAIT_OBJECT_0:
        printf("收到信号---\n");
        break;
    case WAIT_TIMEOUT:
        printf("超时没有收到---\n");
        break;
    case WAIT_ABANDONED:
        printf("另外一个进程意外终止---\n");
        break;
    default:
        break;
    }

    CloseHandle(mutex);
    system("pause");
}

　　文件mutex2.c :

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

char name[100] = "Zhang love Li";

void main()
{
    HANDLE mutex = CreateMutexA(NULL, TRUE, name);
    printf("创建成功！\n");
    char ch = getchar();

    ReleaseMutex(mutex);        //离开互斥区
    printf("触发互斥量.\n");
    CloseHandle(mutex);

    system("pause");
}

　　运行结果：

 2. 事件 event 跨进程通信：

　　文件event.c :

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

char name[100] = "Zhang love Li";

//只有mutex可以感知丢失，event无法感知
void main()
{
    HANDLE event = CreateEventA(NULL, FALSE, FALSE, name);
    printf("创建成功！\n");
    char ch = getchar();

    SetEvent(event);
    printf("触发event.\n");
    CloseHandle(event);

    system("pause");
}

　　文件 wait.c :

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

char name[100] = "Zhang love Li";

void main()
{
    HANDLE event = OpenEventA(EVENT_ALL_ACCESS, TRUE, name);//打开事件
    if (event == NULL)
    {
        printf("打开失败！\n");
        system("pause");
        return;
    }
    printf("等待------\n");

    DWORD res = WaitForSingleObject(event, 10000);
    switch (res)
    {
    case WAIT_OBJECT_0:
        printf("收到信号---\n");
        break;
    case WAIT_TIMEOUT:
        printf("超时没有收到---\n");
        break;
    case WAIT_ABANDONED:
        printf("另外一个进程意外终止---\n");
        break;
    default:
        break;
    }

    CloseHandle(event);
    system("pause");
}

 3. 信号 semaphore 跨进程通信：

　　semaphore.c ：

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

char name[100] = "Zhang love Li";

//只有mutex可以感知丢失，event无法感知
void main()
{
    HANDLE hsem = CreateSemaphoreA(NULL, 0, 1, name);
    printf("创建成功！\n");
    char ch = getchar();

    ReleaseSemaphore(hsem, 1, NULL);
    printf("触发信号量semaphore.\n");
    CloseHandle(hsem);

    system("pause");
}

　　wait.c ：

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

char name[100] = "Zhang love Li";

void main()
{
    HANDLE hsem = OpenSemaphoreA(SEMAPHORE_ALL_ACCESS, TRUE, name);
    if (hsem == NULL)
    {
        printf("打开失败！\n");
        system("pause");
        return;
    }
    printf("等待------\n");

    DWORD res = WaitForSingleObject(hsem, 10000);
    switch (res)
    {
    case WAIT_OBJECT_0:
        printf("收到信号---\n");
        break;
    case WAIT_TIMEOUT:
        printf("超时没有收到---\n");
        break;
    case WAIT_ABANDONED:
        printf("另外一个进程意外终止---\n");
        break;
    default:
        break;
    }

    CloseHandle(hsem);
    system("pause");
}

 五. 回调函数与定时器：

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

//回调函数，函数指针可以来调用
VOID CALLBACK timerun(void *parg, DWORD timearg, DWORD timehigh)
{
    DWORD dwindex = *(DWORD *)parg;
    printf("第%d次\n", dwindex);
}

void main()
{
    HANDLE timer1 = CreateWaitableTimerA(NULL, TRUE, "hello");//创建时钟
    if (timer1 == NULL)
    {
        printf("创建失败！\n");
    }

    LARGE_INTEGER mytime;
    mytime.QuadPart = -50000000;    //单位是0.1微秒

    DWORD dwparam = 1;    //设置定时器

    if (SetWaitableTimer(timer1, &mytime, 1000, timerun, &dwparam, FALSE))//1000 1秒循环一次
    {
        printf("等待5秒后开始干活！\n");
        for (int i = 0; i < 15; i++, dwparam++)    //循环调用多少次
        {
            SleepEx(INFINITE, TRUE);
        }
    }

    CancelWaitableTimer(timer1);//取消定时器
    CloseHandle(timer1);

    system("pause");
}

六. 原子操作：

#include <stdio.h>
#include <stdlib.h>

void main()
{
    volatile int i = 10;    //数据被意外改变的时候，强制读内存
    int a = i;
    printf("i=%d\n", a);

    //偷偷改变i
    __asm
    {
        mov dword ptr[ebp-4],20h    //16进制 20h=32
    }

    int b = i;
    printf("i=%d\n", b);

    system("pause");
}

　　上面结果在Debug模式下结果为：

　　　　　　　　

　　在Release模式下结果为：

　　　　　　　　

 

转载于:https://www.cnblogs.com/si-lei/p/9506292.html

weixin_30906425
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
POSIX 多线程程序设计
GAME-LAB（游戏开发，微信公众号：fury-programer）
02-05 1万+
POSIX 多线程程序设计  Blaise Barney, Lawrence Livermore National Laboratory  目录表 摘要   译者序Pthreads 概述   什么是线程?   什么是Pthreads?   为什么使用Pthreads?   使用线程设计程序
c语言三个线程abc顺序执行,ABC三个线程顺序执行（简单实现）
weixin_39607474的博客
05-25 1682
需求：3个线程 输出ABC ------> ABCABCABC。。。。。此类型1、 使用线程池将所有线程放入一个队列 ，保证顺序输出public class ThreeThread {public static void main(String[] args) throws InterruptedException {//用线程池来实现 ，3个线程加入线程池ExecutorService ...
Linux C (一) 一篇不错的Linux下多线程开发文章[转贴]
diaoqiaoju7163的博客
08-11 75
1 引言 线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix 也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括 Windows/NT，当然，也包括Linux。 为什么有了进程的概念后，还要再引入...
C语言： 多线程（3）-事件和互斥量
C++++ ++
01-13 1076
事件（信号）创建函数： CreateEventA函数：创建或打开一个命名或未命名的事件对象。要为对象指定访问掩码，请使用CreateEventEx函数。 函数原型： HANDLE CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL ...
C语言多线程实例之pthread的应用（在windows下的应用（win7））
yuhushangwei的专栏
01-16 3240
Pthread是由POSIX提出的一套通用的线程库，在linux平台下，它被广泛的支持，而windows平台下，却并不被支持，而pthreads-w32为我们提供了解决方案，本文我们准备在我们的windows平台下进行pthread-w32的安装，在网络上有类似的文章，但是讲的都是比较老的平台，在windows8下支持并不全面，不过可以作为参考。我们在这里贴出几个网址，供参考使用。 Win
c语言多进程多线程编程
07-21
c语言多进程多线程编程
c语言多线程编程使用示例
09-04
主要介绍了c语言多线程编程使用示例,需要的朋友可以参考下
C语言多线程编程实例.pdf
09-30
C语言多线程编程实例.pdf
c语言多线程编程.pdf
09-30
c语言多线程编程.pdf
Sleep、SleepEx
zacklin的专栏
04-13 7506
Sleep和 SleepEx函数的功能是在指定的执行时间内中止所在线程的执行。SleepEx扩展了Sleep的功能，在最短超时时间间隔已到的情况下恢复线程执行外，在以下两种情况下发生时也可以恢复执行：I/O完成回调函数被调用、异步过程调用（APC）被安排进入线程中。 函数原型： VOID WINAPI Sleep(     DWORD dwMillseconds); DWORD WIN
【Sleep、SleepEx】Sleep和 SleepEx函数
b2292486308的博客
06-01 3807
【转自：http://blog.sina.com.cn/s/blog_4c0cb1c001019amf.html】 Sleep和 SleepEx函数的功能是在指定的执行时间内中止所在线程的执行。 SleepEx扩展了Sleep的功能，在最短超时时间间隔已到的情况下恢复线程执行外，在以下两种情况下发生时也可以恢复执行：I/O完成回调函数被调用、异步过程调用（APC）被安排进入线程中。
SleepEx
人生代码，代码人生。。。
03-24 3318
函数原型：DWORD WINAPI SleepEx(DWORD dwMilliseconds,BOOL bAlertable); 说明： SleepEx函数中止当前线程运行直到指定的条件被触发。当以下任意一点出现时，当前线程将恢复运行。 ● I/O回调函数被调用 ● Asynchronous Procedure Call(APC)异步函数被插入线程 ● 当前线程休眠时间超过最小超时值
c语言 标准多线程库,关于C语言多线程pthread库的功能描述
weixin_27923353的博客
05-19 1111
与线程相关的说明һpthread_tpthread_t在头文件/usr/include/bits/pthreadtypes.h中定义:typedef unsigned long int pthread_t;它是一个线程标识符.两个pthread_create函数pthread_create用于创建线程，其原型为:extern int pthread_create __P((pthread_t * ...
linux下c语言的多线程编程
weixin_34092370的博客
10-12 105
我们在写linux的服务的时候，经常会用到linux的多线程技术以提高程序性能 多线程的一些小知识： 一个应用程序可以启动若干个线程。 线程(Lightweight Process，LWP），是程序执行的最小单元。 一般一个最简单的程序最少会有一个线程，就是程序本身，也就是主函数（单线程的进程可以简单的认为只有一个线程的进程） 一个线程阻塞并不会影响到另外一个线程。...
主线程里创建N个子线程，等待N个子线程全部执行完
iteye_15959的博客
04-30 483
1.主线程里创建N个子线程，等待N个子线程全部执行完后，打印每个子线程执行的时间。 import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorSe...
【c++】c++当中多线程函数的使用方法解析，和互斥对象（锁）的使用。（c语言多线程写一个模拟火车票售票程序）
mysterious superstar
04-26 1430
今天用c语言多线程写一个模拟火车票售票程序 #include <windows.h> #include <iostream>//标准输入输出函数库 #include<stdlib.h> using namespace std; DWORD WINAPI Fun1Proc( LPVOID lpParameter // thread data声明线程函数 );...
两个线程轮流对一个全局变量执行加1操作并且打印
suyinfan的博客
04-30 4431
两个线程轮流对一个全局变量执行加1操作并且打印 最近在看多线程编程，想起以前有个电话面试出的题目，今天就写了下，主要是利用互斥变量和条件变量，主线程先执行，然后通知子线程执行，轮流执行++操作，并且打印,代码如下： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;pthread.h&gt; using nam...
关于重叠io完成例程中的sleepEx()
木头刀
09-24 901
写完成例程demo时发现一个问题，在这里记录一下。 对完成例程的介绍中，一般书上还有网上的资料代码都会说在投递完成例程后要调用SleepEx()或者类似的函数使线程处于一种警觉的等待状态，这样线程就会去处理自己apc队列里的apc请求，所以我在我的demo中也是这样做的，测试了一下没有问题。但是后来我试着把SleepEx删掉结果也是正常的，这就奇怪了，如果不调用sleepex之类的函数，
linux下C语言多线程编程实例
weixin_33743661的博客
08-30 435
linux下C语言多线程编程实例学东西，往往实例才是最让人感兴趣的，老是学基础理论，不动手，感觉没有成就感，呵呵。下面先来一个实例。我们通过创建两个线程来实现对一个数的递加。或许这个实例没有实际运用的价值，但是稍微改动一下，我们就可以用到其他地方去拉。下面是我们的代码： /*thread_example.c : c multiple thread programming ...
c语言多线程编程
最新发布
05-31
C语言中，多线程编程可以使用pthread库来实现。使用pthread库需要包含头文件pthread.h。 下面是一个简单的多线程程序示例： ``` #include #include void *start_routine(void *arg) { printf("Hello from ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值