C++线程与网络接口技术（第二节：线程共享、安全与通知等）

于 2016-06-08 20:59:27 发布 536 收藏
分类专栏： C/C++学习笔记 技术杂谈 文章标签： 线程 互斥锁-信号量机制 osapi 轮询机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a18852867035/article/details/51615368
版权

1.线程间共享数据
各线程间可访问全局变量
互斥锁：协调线程，使其步调一致（Mutex）。
g_mutex.lock()//上锁，g_mutex.unlock();//解锁
锁资源由操作系统定义。
互斥锁的使用原则：减少占用时间（尽量缩短对共享数据的访问时间）。
实例：互斥锁

#include <stdio.h>

#include "osapi/osapi.h"

char g_key[16]; // Generator更新它，Checker获取它

class KeyGenerator : public OS_Thread
{
private:
    virtual int Routine()
    {
        int times = 0;
        while(1)
        {
            // 更新key
            for(int i=0; i<16; i++)
            {
                g_key[i] = times;
            }

            times ++;
            if(times >= 128) times = 0;
            OS_Thread::Msleep(50);
        }
        return 0; 
    }
};
class KeyChecker : public OS_Thread
{
private:
    // 线程主函数
    virtual int Routine()
    {
        while(1)
        {       
            // 检查完整性
            for(int i=1; i<16; i++)
            {
                if(g_key[i] != g_key[i-1])
                {                          
                printf("g_key[%d]=%02X,g_key[%d]=%02X\n",
                    i,g_key[i],i-1,g_key[i-1]);
                    PrintKey();
                    printf("不完整!!\n");
                    return 0;
                }
            }

            OS_Thread::Msleep(50);
        }
        return 0; // 正常退出
    }

    void PrintKey()
    {
        printf("Key: ");
        for(int i=0; i<16; i++)
            printf("%02X ", g_key[i]);                  
        printf("\n");
    }
};
int main()
{
    KeyGenerator a;
    a.Run();
    KeyChecker b;
    b.Run();
    getchar();
    return 0;
}

检查线程机制，发现出现错误，出现了读写不一致。
应用锁机制：

#include <stdio.h>
#include "osapi/osapi.h"
OS_Mutex g_mutex;//定义锁
char g_key[16];//全局数据，Generator更新它，Checker获取它
class KeyGenerator:public OS_Thread
{   
private:
    virtual int Routine()
    {
        int times=0;
        while (1)
        {
            //更新key
            ***g_mutex.Lock();//上锁***
            //保证更新时一致
            for (int i=0;i<16;i++)
            {
                OS_Thread::Msleep(5);
                g_key[i]=times;
            }
            ***g_mutex.Unlock();//解锁***
            times++;
            if (times>=128)
            {
                times=0;
            }
            OS_Thread::Msleep(50);
        }
        return 0;
    }
};
class KeyChecker:public OS_Thread
{
private:
    //线程主函数
    virtual int Routine(){
        while(1){
            //数据处理
            //检查完整性
            ***g_mutex.Lock();***
            //保证读机制的完整性
            for (int i=1;i<16;i++)
            {
                if (g_key[i]!=g_key[i-1])
                {
                    printf("不完整！！\n");
                    PrintKey();
                }
            }
            ***g_mutex.Unlock();***
            OS_Thread::Msleep(50);
        }
        return 0;
    }
    void PrintKey(){
        printf("Key: ");
        for (int i=0;i<16;i++)
        {
            printf("%02X",g_key[i]);

        }
        printf("\n");
    }

};
int main(){

    KeyGenerator a;
    a.Run();//启动写线程
    KeyChecker b;
    b.Run();//启动读线程
    getchar();
    return 0;
}

上述锁机制还可以继续改进：因为拷贝的时间相对较短，因此可以替拷贝加锁，然后解锁。具体代码如下：

#include<stdio.h>
#include "osapi/osapi.h"
OS_Mutex g_mutex;//锁机制使用时间不能太长
char g_key[16];
class KeyGenerator :public OS_Thread
{

private:
    virtual int Routine(){
    int times = 0;
    while(1)
    {
        // 先生成key: 需要80ms
        char key_new[16];           
        for(int i=0; i<16; i++)
        {
            OS_Thread::Msleep(5);
            key_new[i] = times;
        }

        // 更新key: 占有锁的时间非常短
        g_mutex.Lock();
        memcpy(g_key, key_new, 16);
        g_mutex.Unlock();
        times ++;
        if(times >= 128) times = 0;
        printf("写！");
    }
    return 0; 
    }
};
class KeyChecker : public OS_Thread
{
private:
    // 线程主函数
    virtual int Routine()
    {
        while(1)
        {       
            // 尽量缩短对共享数据的访问时间
            char copy[16];
            g_mutex.Lock();
            memcpy(copy, g_key, 16);
            g_mutex.Unlock();

            // 数据处理
            // 检查完整性            
            for(int i=1; i<16; i++)
            {
                if(copy[i] != copy[i-1])
                {
                    printf("不完整!!\n");
                    PrintKey();
                    //return 0;
                }
            }   printf("读！\n");     

            OS_Thread::Msleep(50);//必须加上Sleep函数，否则无法实现调度
        }
        return 0; // 正常退出
    }
    void PrintKey()
    {
        printf("Key: ");
        for(int i=0; i<16; i++)
            printf("%02X ", g_key[i]);                  
        printf("\n");
    }
};
int main(){
    KeyGenerator mytask1;
    mytask1.Run();
    KeyChecker mytask2;
    mytask1.Run();
    getchar();
    return 0;
}

主要就是：
更新时上锁：
g_mutex.Lock();
memcpy(g_key,key_new,16);//将生成的16个放入g_key中。
g_mutex.UnLock();
读时上锁：
g_mutex.Lock();
mecpy(copy,g_key,16);//考入copy数组中
g_mutex.UnLock();
2.线程安全函数—-可重入函数
可重入函数：指一个函数，在多个线程里同时调用（并发调用）的时候，其功能任然正常。（线程安全函数）
定义全局变量 int result; 

#include <stdio.h>
#include "osapi/osapi.h"
int result;
int sum(int n){
    result=0;
    for (int i=1;i<=n;i++)
    {
        result+=i;
    }
    return result;
}
class MyTask:public OS_Thread
{
private:
    virtual int Routine()
    {
        while (1)
        {
            int ret=sum(100);
            if (ret !=5050)
            {
                printf("%d\n",ret);
            }

            OS_Thread::Msleep(50);
        }
        return 0;
    }
};
int main(){

    MyTask a;
    a.Run();//启动写线程
    MyTask b;
    b.Run();
    getchar();
    return 0;
}

//出现错误
即全局变量用作为函数参数容易出现错误。
单线程、多线程都可重入时即为可重入函数。
可用互斥锁实现，但最好不要用，耗用系统资源。
3.线程间的通知机制—-信号量机制
生产者–消费者模式：生产者不断往缓存中写东西，消费者不断取走东西。需要保证能够及时取走。
保证能够及时取走的机制：（1）轮询机制（2）信号量机制
（1）轮询机制

#include <stdio.h>
#include "osapi/osapi.h"
#include <time.h>
#include <stdlib.h>
int g_buf[100];//缓存区
OS_Mutex g_mutex;//互斥锁
int g_count=0;
class Producer:public OS_Thread{

public:
    virtual int Routine(){
        while (1)
        {
            int n=rand()%20+1;//生成一个1....20之间的数
            OS_Thread::Msleep(50*n);//50到1000毫秒
            g_mutex.Lock();//上锁
            //存放一个数字代表一个物品 
            g_buf[g_count]=n;
            g_count++;
            printf("放入的物品为:%d\n",n);
            g_mutex.Unlock();//解锁

        }

        return 0;
    } 
};
class Consumer:public OS_Thread
{
public:
    virtual int Routine(){

        while (1)
        {
            OS_Thread::Msleep(500);//每800毫秒取一次
            g_mutex.Lock();//上锁
            if (g_count>0)//g_count小于0就白查了
            {
                for (int i=0;i<g_count;i++)
                {
                    printf("====消费者消费的物品为:%d\n",g_buf[i]);
                }
                g_count=0;
            }
            g_mutex.Unlock();//解锁

        }
        return 0;
    } 

};
int main(){
    srand(time(NULL));//让其产生随机数
    Producer p;
    p.Run();
    Consumer c;
    c.Run();
    getchar();
    return 0;
}

轮询机制的缺点：
1)轮询机制的时间间隔不宜太长，否则缓存区会满；
2)轮询机制的时间不宜太短，否则会百等

（2）信号量机制（semaphore）
及时取，生产一个，消费一个，协调生产和消费。
post()
wait():当信号量大于1时，减1，为0时，自动阻塞
//信号量机制不用加sleep,在消费者中，加sleep代表轮询机制。
具体实现：

#include "osapi/osapi.h"
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
OS_Mutex g_mutex;//锁机制
int g_buf[100];//缓冲区，100个数；
int g_count =0;
OS_Semaphore g_sem(0);//信号量的值初始化为0
// 第一个线程：生产者
class Producer : public OS_Thread
{
public:
    int Routine()
    {
        while(1)
        {

            int r = rand() % 20 + 1; // 生成一个1..20之间的随机数
            OS_Thread::Msleep(50 * r); // 睡觉的间隔50-1000毫秒

            // 存放一个物品(这里就是存一个数, 代表一下物品的意思)
            g_mutex.Lock();
            g_buf[g_count] = r;
            g_count ++;
            printf("放入物品: %d \n", r);
            g_mutex.Unlock();
            g_sem.Post();
        }
        return 0;
    }
};
// 第二个线程：消费者
class Consumer : public OS_Thread
{
public:
    int Routine()
    {
        // 轮询机制：频繁查询当前物品的个数
        while(1)
        {

            //OS_Thread::Msleep(800);
            g_sem.Wait();//检测信号量是否有值，信号量机制自己阻塞；（判断轮询与信号量的方法）
            //wait()重载了超时等待函数，加参数，可以进行超时处理
            g_mutex.Lock();
            if(g_count > 0)
            {
                for(int i=0; i<g_count; i++)
                {
                    printf(" ==== 消费物品: %d \n", g_buf[i]);
                }
                g_count = 0;
            }
            g_mutex.Unlock();
        }
        return 0;
    }
};
int main()
{
    srand(time(NULL));//让其随机生成数
    // 启动第一个线程
    Producer p;
    p.Run();
    // 启动第二个线程
    Consumer c;
    c.Run();
    // 按回车退出程序
    getchar();
    return 0;
}

相比于轮询机制，加了post(),wait(),其余在信号量的消费者中不能用Msleep,因为wait有阻塞机制。post的初始值随初始值而定。
信号量机制：只是相对及时。

4.OSAPI的使用
windows api也可以实现线程编程：

#include <stdio.h>
#include<process.h>
#include <windows.h>
#include <string.h>
//使用windows api实现线程
unsigned int WINAPI OS_Thread(void *param){
    //定义回调函数，必须加上WinAPI
    for (int i=0;i<10;i++)
    {
        printf("do my job:%d\n",i);
        Sleep(1000);
    }
    return 0;
}
unsigned int WINAPI OS_Thread1(void *param){
    //定义回调函数，必须加上WinAPI
    for (int i=0;i<10;i++)
    {
        printf("do your job:%d\n",i);
        Sleep(500);
    }
    return 0;
}
int main(){
    unsigned int thraddr;
    HANDLE handle=(HANDLE) _beginthreadex(NULL,
        0,
        OS_Thread,
        //回调函数(按照MSDN的定义来实现线程定义)
        NULL,0,&thraddr);
    HANDLE handle1=(HANDLE) _beginthreadex(NULL,
        0,
        OS_Thread1,
        //回调函数(按照MSDN的定义来实现线程定义)
        NULL,0,&thraddr);
    getchar();
    return 0;
}

但这种方法不可取，很麻烦，可以直接将其封装后，再使用。

风之清扬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏 更改收藏夹
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++与Web通讯接口
12-17
windows平台C++与web平台通讯接口，可使用域名或ip+port的形式访问web端，通过参数决定使用POST还是GET方法
嵌入式Linux系统：应用开发基础_socket网络通信函数介绍
santirenpc的博客
08-07 299
1、socket() 函数：创建套接字 Linux 中的一切都是文件，每个文件都有一个整数类型的文件描述符；socket 也是一个文件，也有文件描述符。使用 socket() 函数创建套接字以后，返回值就是一个 int 类型的文件描述符。 在 Linux 下使用 <sys/socket.h> 头文件中 socket() 函数来创建套接字，原型为： int...
Socket网络接口编程
07-19
Socket网络接口编程：函数及参数说明，Socket编程核心接口
C++Socket接口编程
最新发布
npu_nazi的博客
03-22 4981
实验目的 1. 学习网络进程间通信 2. 深刻理解Client/Server模型 3. 熟练掌握Socket编程接口(API) 3.1 基于UDP协议通信编程（单向，双向，视频文件传输） 3.2 基于TCP协议通信编程（单向，双向，视频文件传输） 2、实验要求 UDP : n 单向通信：客户端将从键盘输入任意字符串发送给服 务器，服务器接收到后将该字符串在屏幕上打印，并 将客户端IP地址和PORT打印； n 双向通信：（ 1）客户端将从键盘输入任意字符串发送 给服务器，服务器接收到后将该字.
我的服务端之C++网络库对外接口
20386053
12-15 278
大多数的情况下，游戏的服务端都是在Linux下运行，但是Linux下做开发C/C++的开发相对来说是比较困难的。所以一般来说，游戏的服务端都是做成可移植的，这样方便在Windows下做开发。也就是说，服务端既可在Windows下运行，也可以在Linux下运行。说了这么多，看似与网络链接半毛钱关系都没有。 其实不是这样的，就像Lua一样，既可以在Windows下调用它，也可以在Linux调用它，关...
C++网络通信实现
Joey's Blog
08-03 3万+
TCP/IP协议 OSI参考模型：应用层-表示层-会话层-传输层-网络层-数据链路层-物理层。 TCP/IP参考模型：传输控制协议/网际协议是互联网上最流行的协议，采用4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。即应用层-传输层-互联网络层-网络接口层。 数据包格式 IP数据包 IP数据包是在IP协议间发送的，主要在以太网与网际协议模块之间传输，提供无连接...
C++接口的定义与实现
zhanghui962623727的博客
09-01 4万+
1.接口的定义与实现 所谓的接口，即将内部实现细节封装起来，外部用户用过预留的接口可以使用接口的功能而不需要知晓内部具体细节。C++中，通过类实现面向对象的编程，而在基类中只给出纯虚函数的声明，然后在派生类中实现纯虚函数的具体定义的方式实现接口，不同派生类实现接口的方式也不尽相同，从而实现多态。现通过一个简单的实例讲解具体实现步骤(⊙o⊙)。 1.1类接口的定义    通常在头文件中完成类接口
C++ socket网络编程——即时通信系统
热门推荐
斯斯的博客
06-07 5万+
一：项目内容本项目使用C++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室。目的是学习C++网络开发的基本概念，同时也可以熟悉下Linux下的C++程序编译和简单MakeFile编写二：需求分析这个聊天室主要有两个程序：1.服务端：能够接受新的客户连接，并将每个客户端发来的信息，广播给对应的目标客户端。2.客户端：能够连接服务器，并向服务器发送消息，同时可以接收服务器发来的消息。即最简...
C++ 访问http接口
chenzhisi的专栏
04-22 1万+
int GetURLInternal(LPCSTR lpszUrl, std::string& content) { int result = -1; HINTERNET hSession = InternetOpenA(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); if (NULL != hSession) { HINTERNET
Socket简介
weixin_30599769的博客
06-08 269
本文全部摘抄http://c.biancheng.net/cpp/html/3029.html 大多数项目是在Linux下开发服务器端，而在Windows下开发客户端，需要经常在两大平台之间进行切换，单独学习一种平台没有实践意义。两大平台下的 socket 编程非常相似。 在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约...
c++ 如何编写接口类(interface)
a499957739的博客
08-15 2万+
接口类简介：         接口是一系列抽象方法的声明，是一些方法特征的集合，这些方法都应该是抽象的，需要由具体的类去实现，然后第三方就可以通过这组抽象方法调用，让具体的类执行具体的方法。 用c++实现接口类时需要注意一下几点： 1、接口类中不应该声明成员变量，静态变量。 2、可以声明静态常量作为接口的返回值状态，需要在对应的cpp中定义并初始化，访问时需要使用"接口类型::静态常量名"...
C++ Socket编程实例解析
LiTong
10-21 3万+
Socket socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。 在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的
C与C++接口间相互调用
瓦釜苑
03-04 9605
项目中经常使用C和C++混合编程，那么，在调用对方接口时，总是不可避免地出现问题。为了让双方和谐地工作，就得用到extern "C"。
C/C++大文件/数据网络传输方法总结
jmppok的专栏
01-16 1万+
在C/C++网络编程中不免会遇到需要传输大数据、大文件的情况，而由于socket本身缓冲区的限制，大概一次只能发送4K左右的数据，所以在传输大数据时客户端就需要进行分包，在目的地重新组包。而实际上已有一些消息/通讯中间件对此进行了封装，提供了直接发送大数据/文件的接口；除此之外，利用共享目录，ftp，ssh等系统命令来实现大文件/数据也不失为一种好的方法。
C++接口类
成长日记的博客
03-12 6017
在C++中仅含有纯虚函数的类成为接口类，也就是没有数据成员 只有纯虚函数的成员函数 例如~ class Shape { public: virtual double calcArea()=0; virtual double calcPerimeter()=0; } 接口类呢更多的是一种能力或协议~ #include&lt;iostream&gt; #include&lt;strin...
网络接口名称输出到文件的C++实现
Angelo_Chung的博客
07-17 566
网络接口名称输出到文件的C++实现         网络接口名称千奇百怪，而在更改网络设置却要经常用到。有没有可能用什么方法获取网络接口名称，然后输出到指定文件？我的思路如下： 1、使用命令netsh -c interface ip dump >interface.txt，把含有所有网络接口名称的网络配置文件输出到interface.txt中。 Plain Text c
c++中的接口
jerry的博客
06-11 3305
接口的特征：定义了一系列方法，但是没有方法的实现。因此这些方法可以在不同的地方被不同的类实现。这些实现可以有不同的功能。 接口中有抽象方法和
C++线程遇到的问题
qq_33659063的博客
08-22 166
#include #include"osapi/osapi.h" //define a class class MyTask: public OS_Thread { private: virtual int Routine() { for (int i=0; i { printf("ma  mi ma mi hong\n"); OS_Thread::Sleep(1); }
C++类对象共享数据的5种实现方法
程序猿老樊的博客
09-30 1万+
C++中类对数据与行为做了封装，使得私有数据成员不能在类体外被访问，同时类对象之间也不能互相访问对方的私有成员，而在有些情况下，数据既需要保持其私有性，又需要其有共享性，以下将给出两种方式的实现。 一、静态成员变量 #include using namespace std; class sample { private: static char m_sA

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风之清扬

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额：-- )
扫码支付
扫码支付：¥2
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值