c++中CreateEvent函数解析（1）

最新推荐文章于 2024-04-17 16:21:02 发布
最新推荐文章于 2024-04-17 16:21:02 发布
阅读量1.2w 收藏 67
点赞数 10
分类专栏： VC游戏开发/MFC/WTL/ATL/COM

函数原型：


HANDLE CreateEvent(
  LPSECURITY_ATTRIBUTES lpEventAttributes, // SD
  BOOL bManualReset,                       // reset type
  BOOL bInitialState,                      // initial state
  LPCTSTR lpName                           // object name
);

lpEventAttributes：指向SECURITY_ATTRIBUTES结构体，此结构体决定函数的返回句柄是否可以让子进程继承。如果这个参数为NULL，这个句柄是不能继承的。一般情况下，这个参数设置为NULL。

bManualReset：指定将创建的EVENT是自动复位还是手动复位。如果为TRUE，需要用ResetEvent(HANDLE)函数手动复位状态为无信号，即一旦改EVENT被设置成有信号，则它会一直等到ResetEvent调用时才为无信号状态。如果为FALSE，当一个有信号的等待线程被释放后，系统会自动复位状态为无信号状态。

bInitialState：指定事件对象的初始状态。如果为TRUE，初始状态为有信号，否则为无信号。

lpName：  事件对象的名称，以字符串表示。名称的长度受MAX_PATH的限制，名称是大小写敏感的。如果lpName匹配一个存在的命名的事件对象，函数将请求EVENT_ALL_ACCESS来访问存在的对象。在这种情况下，bManualReset和bInitialState 被忽略，因为这两个参数已经被存在的事件设置。如果lpEventAttributes参数不为NULL，这个参数可以决定是否句柄被继承，但是它的安全描述（security-descriptor）成员被忽略。如果lpName 为NULL，创建一个没有名称的事件。如果lpName 匹配一个存在的semaphore, mutex, waitable timer, job或者file-mapping对象的名称，函数调用失败，GetLastError函数返回ERROR_INVALID_HANDLE。由于这些对象共享相同的命名空间，才导致这种情况的发生。

返回值：    函数返回句柄，该句柄具有EVENT_ALL_ACCESS权限去访问新的事件对象，同时它可以在任何需要事件对象句柄的函数中使用。

    调用过程中的任何线程，都可以在一个等待函数中指定事件对象句柄。当指定的对象的状态为有信号时，单对象等待函数（例如WaitForSingleObject）返回。对于多对象等待函数（例如WaitForMultipleObjects），可以指定为任意或所有指定的对象被置为有信号状态。当等待函数返回时，等待线程将被释放去继续它的执行。   事件对象的初始状态由bInitialState参数指定，用SetEvent函数可以设置对象为有信号状态，用ResetEvent函数可以设置对象为无信号状态。   当一个手动复原的事件对象的状态被置为有信号状态时，该对象将一直保持有信号状态，直至明确调用ResetEvent函数将其置为无符号状态。当事件对象被设置为有信号状态时，任何数量的等待线程或者随后等待的线程都会被释放。

    当一个自动复原事件对象的状态被设置为有信号状态时，该对象一直保持有信号状态，直至一个单等待线程被释放；系统然后会自动重置对象到无信号状态。   

多个进程可持有同一个事件对象的多个句柄，可以通过使用此对象来实现进程间的同步。下面的对象共享机制是可行的：

　　·在CreateEvent函数中，lpEventAttributes参数指定句柄可被继承时，通过CreateProcess函数创建的子进程继承的事件对象句柄。

　　·一个进程可以在DuplicateHandle函数中指定事件对象句柄，从而获得一个复制的句柄，此句柄可以被其它进程使用。

      ·一个进程可以在OpenEvent或CreateEvent函数中指定一个名字，从而获得一个有名的事件对象句柄。（在调用OpenEvent或CreateEvent函数时，一个进程可以指定事件对象的名字。）

　　使用CloseHandle函数关闭句柄。当进程终止时，系统将自动关闭句柄。事件对象会被销毁，当最后一个句柄被关闭。


二、c++CreateEvent函数在多线程中使用及实例

下面主要演示一下采用CreateEvent实现多线程。

例子很简单，主要测试CreateEvent中bManualReset:和bInitialState参数的取值在线程调用中信号状态的情况。


测试1：

bManualReset：TRUE
bInitialState：TRUE

CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态

example.cpp

    #include "iostream"  
    #include "windows.h"  
    using namespace std;  
      
    DWORD WINAPI ThreadProc1(LPVOID lpParam);  
    DWORD WINAPI ThreadProc2(LPVOID lpParam);  
    HANDLE hEvent = NULL;  
    HANDLE hThread1 = NULL;  
    HANDLE hThread2 = NULL;  
    int main(int argc, char *args[])  
    {  
        hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)</span>; //使用手动重置为无信号状态，初始化时有信号状态  
        //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
        //if (SetEvent(hEvent))  
        //{  
        //  cout << "setEvent 成功" <<endl;  
        //}  
        hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
        Sleep(200);  
        hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
        Sleep(200);  
        if ( NULL == hThread1)  
        {  
            cout <<"create thread fail!";  
        }  
        //DWORD dCount = ResumeThread(hThread);  
        //cout << LOWORD(dCount) << endl;  
        return 0;  
    }  
    DWORD WINAPI ThreadProc1(LPVOID lpParam)  
    {  
        cout <<"in thread1@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<" thread1 signaled ! "<<endl;  
        }  
        cout <<"in thread1 --signal"<<endl;  
          
        //SetEvent(hEvent);  
        return 0;  
    }  
    DWORD WINAPI ThreadProc2(LPVOID lpParam)  
    {  
        cout <<"in thread2@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<"thread2 signaled ! "<<endl;  
        }  
        cout <<"in thread2--signal"<<endl;  
          
        return 0;  
    }

执行结果：


从结果中看，执行完线程1又执行了线程2.

由于hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)，使用手动重置为无信号状态，初始化时有信号状态

所以hEvent一直处于有信号状态，无论是线程1释放后，hEvent仍处于有信号状态，所以线程2正常执行了。


测试2：

bManualReset：FALSE
bInitialState：TRUE


hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态

example2.cpp 

    #include "iostream"  
    #include "windows.h"  
    using namespace std;  
      
    DWORD WINAPI ThreadProc1(LPVOID lpParam);  
    DWORD WINAPI ThreadProc2(LPVOID lpParam);  
    HANDLE hEvent = NULL;  
    HANDLE hThread1 = NULL;  
    HANDLE hThread2 = NULL;  
    int main(int argc, char *args[])  
    {  
        //hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
        hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); </span>//当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
        //if (SetEvent(hEvent))  
        //{  
        //  cout << "setEvent 成功" <<endl;  
        //}  
        hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
        Sleep(200);  
        hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
        Sleep(200);  
        if ( NULL == hThread1)  
        {  
            cout <<"create thread fail!";  
        }  
        //DWORD dCount = ResumeThread(hThread);  
        //cout << LOWORD(dCount) << endl;  
        return 0;  
    }  
    DWORD WINAPI ThreadProc1(LPVOID lpParam)  
    {  
        cout <<"in thread1@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<" thread1 signaled ! "<<endl;  
        }  
        cout <<"in thread1 --signal"<<endl;  
          
        //SetEvent(hEvent);  
        return 0;  
    }  
    DWORD WINAPI ThreadProc2(LPVOID lpParam)  
    {  
        cout <<"in thread2@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<"thread2 signaled ! "<<endl;  
        }  
        cout <<"in thread2--signal"<<endl;  
          
        return 0;  
    }
执行结果：

从执行结果中分析，执行了线程1，线程2一直在等待，直到主线程结束。

由于hEvent = CreateEvent(NULL, FALSE, TRUE, NULL)，当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态

初始执行线程1的时候，hEvent是有信号的，所以线程1正常执行；又由于bManualReset=FALSE，所以执行完线程1后，hEven

WaitForSingleObject(hEvent,INFINITE);

函数一直在等待hEvent变为有信号状态，但是当主线程执行完，还没等待到，线程2程序一直没有走下去。


测试3：

bManualReset：TRUE
bInitialState：FALSE

hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态

example3.cpp

    #include "iostream"  
    #include "windows.h"  
    using namespace std;  
      
    DWORD WINAPI ThreadProc1(LPVOID lpParam);  
    DWORD WINAPI ThreadProc2(LPVOID lpParam);  
    HANDLE hEvent = NULL;  
    HANDLE hThread1 = NULL;  
    HANDLE hThread2 = NULL;  
    int main(int argc, char *args[])  
    {  
        //hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
        //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
        hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态</span>  
        //if (SetEvent(hEvent))  
        //{  
        //  cout << "setEvent 成功" <<endl;  
        //}  
        hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
        Sleep(200);  
        hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
        Sleep(200);  
        if ( NULL == hThread1)  
        {  
            cout <<"create thread fail!";  
        }  
        //DWORD dCount = ResumeThread(hThread);  
        //cout << LOWORD(dCount) << endl;  
        return 0;  
    }  
    DWORD WINAPI ThreadProc1(LPVOID lpParam)  
    {  
        cout <<"in thread1@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<" thread1 signaled ! "<<endl;  
        }  
        cout <<"in thread1 --signal"<<endl;  
          
        //SetEvent(hEvent);  
        return 0;  
    }  
    DWORD WINAPI ThreadProc2(LPVOID lpParam)  
    {  
        cout <<"in thread2@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<"thread2 signaled ! "<<endl;  
        }  
        cout <<"in thread2--signal"<<endl;  
          
        return 0;  
    }
执行结果，可想而知，只能输出：
in thread1@! 
 in thread2@! 
 因为初始为无信号状态，所以hEvent一直处于无信号状态，因此这两个线程一直在等待，直到主线程结束。


修改：放开例子中的注释部分：

if (SetEvent(hEvent))//设置信号为有信号状态
{
cout << "setEvent 成功" <<endl;
}

执行结果：


可见，线程1和线程2都执行了。

因为调用SetEvent，事件变为有信号状态，线程1执行；又由于线程1释放后，hEvent仍旧处于有信号状态，所以线程2也执行了。


再修改:在线程1中，添加ResetEvent(hEvent)（手动设置事件为无信号状态），则线程2不会执行。


测试4：

bManualReset：FALSE
bInitialState：FALSE

hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);//线程释放后自动重置为无信号状态，初始化时为无信号状态

example4.cpp

    #include "iostream"  
    #include "windows.h"  
    using namespace std;  
      
    DWORD WINAPI ThreadProc1(LPVOID lpParam);  
    DWORD WINAPI ThreadProc2(LPVOID lpParam);  
    HANDLE hEvent = NULL;  
    HANDLE hThread1 = NULL;  
    HANDLE hThread2 = NULL;  
    int main(int argc, char *args[])  
    {  
        //hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
        //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
        //hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态  
        hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态  
        if (SetEvent(hEvent))  
        {  
            cout << "setEvent 成功" <<endl;  
        }  
        hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
        Sleep(200);  
        hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
        Sleep(200);  
        if ( NULL == hThread1)  
        {  
            cout <<"create thread fail!";  
        }  
        //DWORD dCount = ResumeThread(hThread);  
        //cout << LOWORD(dCount) << endl;  
        return 0;  
    }  
    DWORD WINAPI ThreadProc1(LPVOID lpParam)  
    {  
        cout <<"in thread1@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<" thread1 signaled ! "<<endl;  
        }  
        cout <<"in thread1 --signal"<<endl;  
          
        //SetEvent(hEvent);  
        return 0;  
    }  
    DWORD WINAPI ThreadProc2(LPVOID lpParam)  
    {  
        cout <<"in thread2@!"<<endl;  
          
        DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
          
        if ( WAIT_OBJECT_0 == dReturn)  
        {  
            cout <<"thread2 signaled ! "<<endl;  
        }  
        cout <<"in thread2--signal"<<endl;  
          
        return 0;  
    }



由于调用SetEvent，hEvent为有信号状态，线程1正常执行，又由于调用完线程1后，hEvent自动重置为无信号状态，所以线程2只能在等待，直到主线程退出。

修改：线程1中的SetEvent(hEvent);的注释去掉，再运行，则线程1和线程2 都会执行。






Jackchenyj
关注
  • 10
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
windows线程 事件CreateEvent、SetEvent、ResetEvent、CloseHandle
单于的学习历程
11-28 1279
windows线程 事件CreateEvent、SetEvent、ResetEvent、CloseHandle
C++设置事件通知线程工作的方法
09-04
创建事件对象时，`CreateEvent`函数的第二个参数`bManualReset`设为`FALSE`，表示这是一个自动重置事件。以下是关键代码段的解析： ```cpp // 创建一个初始状态为非受信（未触发）的事件对象 g_event = ::...
CreateEvent()函数
乐观开朗，积极向上
08-21 1149
FROM:http://blog.csdn.net/jackey3lin/article/details/50380347 CreateEvent 用来创建或打开一个命名的或无名的事件对象，对于它的其他解释，请自行百科，这里只简单描述它的两种常用用法！ CreateEvent 的官方定义如下： [cpp] view plain copy
C++ 事件（event）使用总结
AI浩
09-03 1万+
事件最常用在多线程同步互斥机制。 常用的函数有： 1、CreateEvent 创建事件。 函数原型如下所示，一共四个参数： HANDLE CreateEvent( 　LPSECURITY_ATTRIBUTES lpEventAttributes,　// SECURITY_ATTRIBUTES结构指针，可为NULL 　BOOL bManualReset, // 手动/自动 　 // TRUE：表示手动，在WaitF...
C++基础之事件处理函数介绍（CreatEvent() /WaitForSingleObject）：
gege_hxg的博客
11-16 1210
1.事件函数之CreatEvent() : 函数格式： HANDLE CreateEvent( LPSECURITY_ATTRIBUTES lpEventAttributes, // SD BOOL bManualReset, // reset type BOOL bInitialState, // initial state LPCTSTR lpName
CreateEvent(NULL,TRUE,FALSE,NULL);的解释
物联网小镇的博客
12-20 2079
初始化为： m_hReadEvent=CreateEvent(NULL,TRUE,FALSE,NULL); 1.，确定返回的句柄是否可被子进程继承.如果lpEventAttributes是NULL，此句柄不能被继承。 2.指定将事件对象创建成手动复原还是自动复原。如果是TRUE，那么必须用ResetEvent函数来手工将事件的状态复原到无信号状态。如果设置为FALSE，当一个等待线程被释放以后，系...
C语言-内存映射（大文件处理）（创建文件映射内核对象然后在映射到内存地址空间中，当作无类型指针使用）
TRW777
02-29 1937
C语言-内存映射是什么，根据自己粗浅的学习理解，总结为——创建一个文件映射内核对象然，然后在把文件映射内核对象映射到内存地址空间中，然后我们拿这个内存地址（也就是无类型类型指针）对内存空间（也就相当与硬盘上的文件）进行操作了。 这里面包含了三大内容（内村指针就不介绍了）：文件打开或创建、文件映射内核对象，映射文件映射到内存地址空间 1、文件打开或创建CreateFile CreateFi...
IcmpSendEcho2Ex_Demo
01-23
5. 解析并处理响应数据：如果成功，可以从`ReceiveBuffer`中解析出响应信息，包括往返时间、数据大小等。 在C++中，实现`IcmpSendEcho2Ex`同步模式的ping，需要包含以下关键步骤： 1. 引入必要的头文件，如`...
Visual C++_Turbo C串口通信编程实践
07-25
在Visual C++中，可以通过Windows API函数如CreateFile、WriteFile和ReadFile来实现串口通信。首先，需要打开串口（CreateFile），然后设置串口参数（SetCommState），最后进行读写操作。在Turbo C中，由于不直接...
VC++里的线程解析
12-07
在VC++中，可以使用Windows API函数CreateThread或C++标准库中的std::thread来创建线程。CreateThread是原生的Windows方法，适用于低级线程操作；而std::thread是C++11引入的跨平台线程支持，提供了更高级别的抽象。...
线程中CreateEvent和SetEvent及WaitForSingleObject的用法
12-01
线程中CreateEvent和SetEvent及WaitForSingleObject的用法
C++Event机制的简单实现
02-24
C++Event机制的简单实现
C++ 中CloseHandle 函数--关闭一个句柄
08-30
主要介绍了C++ 中CloseHandle 函数--关闭一个句柄的相关资料,需要的朋友可以参考下
vc调用api函数进行串口通讯,能够实现对omronPLC的串口通讯,能够实现对omronPLC的数据区的读取和写入.rar
最新发布
06-20
在本文中，我们将深入探讨如何使用Visual C++（VC++）和MFC（Microsoft Foundation Classes）框架调用API函数来实现串口通信，特别是在与Omron PLC进行数据交互的上下文中。串口通信是设备间通信的一种常见方式，...
CreateEvent的使用方法
weixin_34148508的博客
09-09 168
 CreateEvent的使用方法收藏 新一篇: PreCreateWindow的作用和用法 | 旧一篇: VC中_T()的作用 事件对象就像一个开关：它仅仅有两种状态---开和关。当一个事件处于”开”状态，我们称其为”有信号”否则称为”无信号”。能够在一个线程的运行函数中创建一个事件对象，然后观察它的状态，假设是”无信号”就让该线程睡眠，这样该线程占用的CPU时间就比...
C++ 利用管道操作本机命令行命令
qq490765184的博客
02-18 2506
目录 1.知识要点 1.1 进程创建与关闭 1.2 管道的创建与关闭 2.利用MFC创建命令行命令执行工具 2.1 界面创建 2.2 命令执行函数 2.3 测试 1.知识要点 1.1 进程创建与关闭 在C++中，创建一个进程，需要利用WINDOWS API函数，该函数的原型如下： BOOL CreateProcessA( LPCSTR ...
Windows下创建进程-CreateProcess()
热门推荐
夜、醉梦红尘
11-27 3万+
函数说明： CreateProcess是Windows下用于创建进程的API函数,用来创建一个新的进程和它的主线程，这个新进程运行指定的可执行文件。 函数原型： BOOL CreateProcess (     LPCTSTR lpApplicationName,             LPTSTR lpCommandLine,             LPSECURITY_ATT
C++ creatEvent使用
xiao_mifa的博客
04-17 213
如果为TRUE，当事件被触发后，即使有多个等待线程被唤醒，事件状态将保持“有信号”状态，直到显式调用ResetEvent()函数将其重置为“无信号”。如果为FALSE，事件为自动重置类型，一旦有一个等待线程被唤醒，事件会自动变为“无信号”，其他等待线程将继续阻塞。创建了一个手动重置事件，一旦它被触发，所有等待的线程都会被唤醒，并且事件状态保持为“有信号”，直到程序明确调用ResetEvent(hEvent)来将其重置为“无信号”。如果为NULL，创建的是一个本地事件，只能在同一进程中访问。
Windows API——CreateEvent和SetEvent函数
Nancy_m的专栏
09-30 3945
Windows API——CreateEvent和SetEvent函数 （1）CreateEvent 函数原型： HANDLE CreateEvent( 　　     LPSECURITY_ATTRIBUTES lpEventAttributes, // 安全属性 　　     BOOL bManualReset, // 复位方式 　　     BOOL bInitialS
createevent函数参数的含义
06-11
`CreateEvent` 函数是用于创建或打开一个事件（Event）对象的函数。它有四个参数： 1. `LPSECURITY_ATTRIBUTES lpEventAttributes`: 指向一个 `SECURITY_ATTRIBUTES` 结构体的指针，用于指定事件对象的安全属性。如果该参数为 `NULL`，则表示使用默认的安全属性。 2. `BOOL bManualReset`: 表示事件对象的重置模式。如果该参数为 `TRUE`，则事件对象是手动重置模式，如果该参数为 `FALSE`，则事件对象是自动重置模式。 3. `BOOL bInitialState`: 表示事件对象的初始状态。如果该参数为 `TRUE`，则表示事件对象初始为有信号状态（signaled state），如果该参数为 `FALSE`，则表示事件对象初始为无信号状态（nonsignaled state）。 4. `LPCTSTR lpName`: 表示要创建或打开的事件对象的名称。如果该参数为 `NULL`，则创建一个没有名称的匿名事件对象；如果要创建或打开的事件对象已经存在，则该参数指定该事件对象的名称。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值