计算机中通信的思考（一针见血，见解深刻，待追风仔细研读）

最新推荐文章于 2022-12-04 16:25:17 发布
最新推荐文章于 2022-12-04 16:25:17 发布
阅读量715 收藏
点赞数

计算机中通信的思考http://blog.csdn.net/ktigerhero3/article/details/49994397

一切皆为联系，现代计算机更是将联系发挥到极致，《终结者》中的无处不在的AI终将实现，本文总结了对象（计算机，手机，智能家居）及（进程，线程）之间的通信。

1.相同计算机不同进程间通信

不同进程间的常用通信方式： 
管道( pipe )、有名管道 (named pipe)、信号量( semophore ) 、消息队列( message queue )、信号 ( sinal ) 、共享内存( shared memory ) 
套接字( socket )

1.1父子进程通信

如图中的父进程PA与子进程CA1之间的通信 
这里写图片描述 
在一个操作系统中有很多个进程，这些进程的调度由操作系统完成。 
需要解决的问题： 
如何新建一个父进程PA和一个子进程CA1，然后父进程发送消息（“Son progress,I am father progress.”）给子进程,子进程收到消息后回答（”Father progress,I am son progress.”）？

1.2非父子进程间的通信

如图中的进程PA与进程PB之间的通信

1.2.1需要解决的问题：

如何新建进程PA和进程PB，然后进程PB发送消息（“Hello friend,I am progress PA.”）给进程PA?

1.2.2利用有名管道实现不同进程间的通信

如图为进程PA和PB利用管道进行通信的示意图： 
这里写图片描述 
（1）服务器端 
思路： 
1）创建命名管道，调用函数 CreateNamedPipe（）； 
2）创建事件，绑定事件，调用CreateEvent（） 
3）连接管道，等待客户端连接请求调用函数ConnectNamedPipe（） 
4）使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止，调用WaitForSingleObject（） 
5）当管道收到数据，读取数据，调用ReadFile（） 
服务器端代码如下：

#include<windows.h>
#include<iostream>
using namespace std;
int main()
{
    //将const char*转换为LPCWSTR
    const char* charpipeName = "\\\\.\\pipe\\MyPipe";
    WCHAR pipeName[256];
    memset(pipeName, 0, sizeof(pipeName));
    MultiByteToWideChar(CP_ACP, 0, charpipeName, strlen(charpipeName) + 1, pipeName,
        sizeof(pipeName) / sizeof(pipeName[0]));
    //创建命名管道
    HANDLE hPipe = CreateNamedPipe(pipeName,
        PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
        0, 1, 1024, 1024, 0, NULL);
    if (INVALID_HANDLE_VALUE == hPipe)
    {
        cout << "创建命名管道失败！" << endl;
        hPipe = NULL;
        return 0;
    }
    //创建事件
    HANDLE hEvent;
    hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (!hEvent)
    {
        cout << "创建事件对象失败！" << endl;
        CloseHandle(hPipe);
        hPipe = NULL;
        return 0;
    }
    OVERLAPPED ovlap;
    ZeroMemory(&ovlap, sizeof(OVERLAPPED));
    ovlap.hEvent = hEvent;
    //等待客户端连接请求
    if (!ConnectNamedPipe(hPipe, &ovlap))
    {
        if (ERROR_IO_PENDING != GetLastError())
        {
            cout << "等待客户端连接失败！" << endl;
            CloseHandle(hPipe);
            CloseHandle(hEvent);
            hPipe = NULL;
            return 0;
        }
    }
    //使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止
    if (WAIT_FAILED == WaitForSingleObject(hEvent, INFINITE))
    {
        cout << "等待对象失败！" << endl;
        CloseHandle(hPipe);
        CloseHandle(hEvent);
        hPipe = NULL;
        return 0;
    }
    CloseHandle(hEvent);

    /////////////////////////////////////////读取内容
    char buf1[100];
    DWORD dwRead;
    if (!ReadFile(hPipe, buf1, 100, &dwRead, NULL))
    {
        cout << "ReadFile failed" << endl;
        return 0;
    }
    else
    {
        cout << "读取成功" << endl;
        cout << buf1 << endl;
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72

（2）客户端 
思路： 
1）判断是否有命名管道实例，调用WaitNamedPipe（） 
2）连接命名管道，调用CreateFile（） 
3）向管道写入内容，调用WriteFile（） 
客户端实现代码如下：

#include<windows.h>
#include<iostream>
using namespace std;

int main()
{
    //将const char*转换为LPCWSTR
    const char* charpipeName = "\\\\.\\pipe\\MyPipe";
    WCHAR pipeName[256];
    memset(pipeName, 0, sizeof(pipeName));
    MultiByteToWideChar(CP_ACP, 0, charpipeName, strlen(charpipeName) + 1, pipeName,
        sizeof(pipeName) / sizeof(pipeName[0]));

    HANDLE hPipe;
    //判断是否有命名管道实例
    if (!WaitNamedPipe(pipeName, NMPWAIT_WAIT_FOREVER))
    {
        cout << "当前没有可利用的命名管道实例！" << endl;
        return 0;
    }

    //连接命名管道
    hPipe = CreateFile(pipeName, GENERIC_READ | GENERIC_WRITE,
        0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (INVALID_HANDLE_VALUE == hPipe)
    {
        cout << "打开命名管道失败！" << endl;
        hPipe = NULL;
        return 0;
    }else
    {
        cout << "打开管道成功" << endl;
    }

    //写入内容
    char buf[100] = "Hello friend,I am progress PB.I am client progress.";
    DWORD dwWrite;
    if (!WriteFile(hPipe, buf, strlen(buf) + 1, &dwWrite, NULL))
    {
        cout << "WriteFile failed" << endl;
        return 0;
    }
    else
    {
        cout << "写入成功" << endl;
    }
    return 0;
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

2.相同进程间的线程的通信

由于同一进程之间的不同线程共享进程中的代码，数据和文件，因此同一进程中线程间通信通常使用共享来通信。 
例如：

3.不同进程间的线程的通信

这个问题包括相同进程间线程的通信和不同进程间进程的通信两个问题。分别解决就实现了不同进程间线程的通信。 
每个进程都有一个主线程，进程间共享数据的最佳方法是使用内存映射文件。

3.1要解决的问题

如何通过内存映射达到两个进程PA与PB交换信息的效果？如有一段字符串“Hello friend,I am progress PA.”如何在PA与PB间共享。

3.2利用内存映射在不同进程间共享数据

不同进程通过存储器映射共享对象如图所示这里写图片描述 
如图所示，共享内存的关键是创建进程和物理存储器的映射关系。 
进程PA（实现在内存中写数据）代码 
思路 
1）创建文件 
2）创建映射 
3）在内存（即view视图）中写入需要的共享的数据 
4）取消映射 
代码如下：

#include <windows.h>
#include <stdio.h>
#include <conio.h>
/* 预处理申明　*/
#define BUF_SIZE 256
/* 全局变量　*/
LPTSTR szName = TEXT("SharedFileMappingObject");
LPTSTR szMsg = TEXT("进程的消息");
void main(int argc, PCHAR argv[])
{
    //文件映射句柄
    HANDLE hMapFile;
    //共享数据缓冲区指针
    LPTSTR pBuf;
    //创建命名的文件映射，不代表任务硬盘上的文件
    hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,
        NULL,
        PAGE_READWRITE,
        0,
        BUF_SIZE,
        szName);
    if (hMapFile == NULL || hMapFile == INVALID_HANDLE_VALUE)
    {
        printf("CreateFileMapping error: %d\n", GetLastError());
        return;
    }
    //创建View
    pBuf = (LPTSTR)MapViewOfFile(hMapFile,
        FILE_MAP_ALL_ACCESS,
        0,
        0,
        BUF_SIZE);
    if (pBuf == NULL)
    {
        printf("MapViewOfFile error %d\n", GetLastError());
        return;
    }
    //将共享数据复制到文件映射中，如果运行时输入了参数则使用参数
    if (argc == 1)
    {
        CopyMemory((PVOID)pBuf, szMsg, strlen(szMsg));
    }
    else
    {
        DWORD dwCopyLen = (lstrlen(argv[1])<BUF_SIZE) ? lstrlen(argv[1]) : BUF_SIZE;
        CopyMemory((PVOID)pBuf, argv[1], dwCopyLen);
    }
    printf("运行程序，完成运行后，按任意键退出。");
    _getch();
    //取消映射，退出
    UnmapViewOfFile(pBuf);
    CloseHandle(hMapFile);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

进程PB（实现在内存中读数据）代码 
思路 
1）通过文件名打开文件映射 
2）读映射文件中的内容 
3）显示得到的共享数据 
4）关闭句柄 
代码如下：

#include <windows.h>
#include <stdio.h>
#include <conio.h>
/* 预处理申明　*/
#define BUF_SIZE 256
/* 全局变量　*/
LPTSTR szName = TEXT("SharedFileMappingObject");
LPTSTR szMsg = TEXT("进程的消息");
void main(int argc, PCHAR argv[])
{
    //文件映射句柄
    HANDLE hMapFile;
    //共享数据缓冲区指针
    LPTSTR pBuf;
    //创建命名的文件映射，不代表任务硬盘上的文件
    hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,
        NULL,
        PAGE_READWRITE,
        0,
        BUF_SIZE,
        szName);
    if (hMapFile == NULL || hMapFile == INVALID_HANDLE_VALUE)
    {
        printf("CreateFileMapping error: %d\n", GetLastError());
        return;
    }
    //创建View
    pBuf = (LPTSTR)MapViewOfFile(hMapFile,
        FILE_MAP_ALL_ACCESS,
        0,
        0,
        BUF_SIZE);
    if (pBuf == NULL)
    {
        printf("MapViewOfFile error %d\n", GetLastError());
        return;
    }
    //将共享数据复制到文件映射中，如果运行时输入了参数则使用参数
    if (argc == 1)
    {
        CopyMemory((PVOID)pBuf, szMsg, strlen(szMsg));
    }
    else
    {
        DWORD dwCopyLen = (lstrlen(argv[1])<BUF_SIZE) ? lstrlen(argv[1]) : BUF_SIZE;
        CopyMemory((PVOID)pBuf, argv[1], dwCopyLen);
    }
    printf("运行程序，完成运行后，按任意键退出。");
    _getch();
    //取消映射，退出
    UnmapViewOfFile(pBuf);
    CloseHandle(hMapFile);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

4.不同计算机的通信，客户端和服务器端的通信过程

实现计算机PCA的进程pca_progress到计算机PCB中的进程pcb_progress之间的通信。 
例如：计算机PCA中的进程pca_progress，发送消息（“Hello friend,I am coputer A,my pid is pca_progress.”）给计算机PCB,PCB中的进程pcb_progress收到消息后回答（”“Hello friend,I am coputer B,my pid is pcb_progress.”）

5.手机与计算机的通信

手机和计算机的通信其实和计算机和计算机通信相类似。手机可以看做是一台装了操作系统（Android系统，IOS系统）的计算机。Android系统架构为四层结构，从上层到下层分别是应用程序层、应用程序框架层、系统运行库层以及Linux内核层。 
因此，安卓手机和PC通信同样采用socket通信。 
（1）理解socket 
计算机网络体系结构如图 
这里写图片描述 
而 socket是在应用层和传输层之间的一个抽象层，它把网络层和传输层各种复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。 
如下图表示了socket抽象。 
这里写图片描述
思路如下： 
（1）PC端（服务器端）socket 
系统如果为linux,则可以采用linux系统下的系统调用函数直接创建服务器端。linux系统下包括<sys/socket.h>利用创建套接字的标准流程新建一个服务器端套接字。 
系统如果是windows,这调用windows系统API，包含<winsock.h>就能调用windows系统下的API。 
（2）手机端（客户端）socket 
手机端socket 调用import java.net.Socket和ServerSocket包中的socket类 。创建客户端套接字。 
实现代码可以参考（本人还未实现~） 
http://blog.csdn.net/yanjiaye520/article/details/7567309

6.手机与手机的通信

7.手机与智能家居的通信

8.web网站中前端和后端通信

9.ajax异步通信方式原理


shengDay
关注
专栏目录
计算机中通信的思考
沧海一帆的专栏
11-23 841
一切皆为联系，现代计算机更是将联系发挥到极致，《终结者》中的无处不在的AI终将实现，本文总结了对象（计算机，手机，智能家居）及（进程，线程）之间的通信。1.相同计算机不同进程间通信不同进程间的常用通信方式： 管道( pipe )、有名管道 (named pipe)、信号量( semophore ) 、消息队列( message queue )、信号 ( sinal ) 、共享内存( shared
揭秘计算机内部通信：探秘数据、地址与控制信号的奥秘
最新发布
kfashfasf的博客
01-02 914
本文深入介绍了计算机系统中至关重要的总线概念。总线是计算机内部各组件间通信的桥梁，涉及数据、地址和控制信号的传输。文章解释了不同类型的总线，包括数据线、地址线和控制线，并详细探讨了它们在CPU、内存和其他硬件部件之间的作用。地址总线的宽度决定了CPU可以寻址的存储单元数量，数据总线的宽度影响数据传输速度，而控制总线负责传递各种控制信号，确保计算机内部各部件的协调运作。通过对总线系统的深入理解，读者可以更好地了解计算机硬件架构，为进一步学习和研究提供了基础。努力的小雨。
计算机网络与通信的重要性,浅谈计算机网络与通信技术-20210716002727.docx-原创力文档...
weixin_32233571的博客
07-30 620
浅谈计算机网络与通信技术浅谈计算机网络与通信技术南京信息工程大学滨江学院计算机网络课程论文计算机网络通信技术的发展概况班 名：崔兆良 号：[1**********] 业：信息与计算科学 级：2021(1)班任课教师： 何绍奎2021 年 12 月南京信息工程大学滨江学院计算机网络课程论文计算机网络通信技术的发展概况摘 要 本文主要介绍了计算机网络的发展概况，通过介绍计算机网络网络的分类和用途，通信...
第五篇：计算机内部悄悄话，进程间通信全解析
毛毛的专栏
08-10 530
文章目录一、前言二、进程间通信如何实现进程间通信？进程间通信的方式三、进程间通信方式：管道第一种管道：匿名管道第二种管道：命名管道管道读写(先将数据写入管道，再从管道中读出数据)进程间通信：管道的优缺点管道底层的系统调用匿名管道(新建、输入、输出)管道双向通信就要创建两个管道四、进程间通信：消息队列五、进程间通信：共享内存六、进程间通信：信号量七、进程间通信：信号八、跨网络不同主机之间进程通信：Socket针对 TCP 协议通信的 socket 编程模型针对 UDP 协议通信的 socket 编程模型针对本
计算机之间通信
多头注意力探索Now
01-27 158
来源《操作系统原理》
【物理动图】物理老师一针见血：50张动图看懂高中物理
01-07
图中两个弹簧的弹力大小是否一样？若一样，为什么？自行车前后轮所受力的方向是什么？物块所受支持力和摩擦力的大小是如何变化的？两个力合力的大小范围是什么？如果水平面光滑且无穷长小车将做何种运动？动力学突然...
电源技术中的OEM选择了谁的ASIC？
12-08
但是，调查结果却显示，7大IC应用领域(通信系统、网络设备、消费类电子、计算机、工控、医疗、汽车电子)中，选择本土公司作为ASIC来源的整机厂商比重仍然很低，大都在10%左右徘徊。而在推动IC产业发展的消费类电子、...
图像配准中的MATLAB 高斯滤波实战指南：精准对齐，一针见血
![matlab高斯滤波]...# 1. 图像配准基础 图像配准是指将两幅或多幅图像对齐的过程，使其具有相同的几何参考系。图像配准在计算机视觉、医学成像和遥感等领域有着广泛的应用。 图像配准通常涉及以
javascript基础，一针见血的
05-29
运算符优先级决定了在表达式中运算符的执行顺序，是理解和编写JavaScript代码中的一个关键点。 控制程序流程主要通过条件语句（如if-else）和循环语句（如for、while）来实现。这些语句允许根据条件执行不同的代码...
大话计算机 文泉高清版
scone5的博客
04-23 5065
笔者自述 我眼中的冬瓜哥是一位跨学科的江湖奇才。他在《大话计算机》一书里，从计算机入门者的角度出发，以自问自答、问题导向的方式，剖析了计算机的底层，以图片加文字的方式生动地描绘了计算机的各个部件的最新工作细节和原理，帮助读者透彻地理解现代计算机的工作方式，扎实地掌握相关知识。阅读本书的过程，俨然就像一位老师在给一个对计算机完全不懂的人从零开始，事无巨细，循循善诱，循序渐进的讲授过程。冬瓜哥能够清晰地切中要害，深知初学者的思维阻碍在哪里，然后一针见血地打通初学者的任督二脉。所谓茅塞顿开，醍醐灌顶，也就是如此感
NamedPipe命名管道通信
03-20
用MFC做的客户端和服务器，只是简单地传输文字、自动接收，用命名管道技术。可以用来新手学习
visual c++ vc使用命名管道CreateNamedPipe例子源代码.zip
01-20
visual c++ vc使用命名管道CreateNamedPipe例子源代码.zip
mmap实现进程间通信（父子进程、非父子进程）
challenglistic的博客
12-04 880
mmap实现进程间通信（父子进程、非父子进程）
【Linux】进程间通信
qq_53893431的博客
11-06 1532
进程间通信
常见进程间的几种通信方式以及使用注意点
bingshiwuyu的专栏
12-14 4435
常见进程间的几种通信方式以及使用注意点 通常情况下进程间的通信方式主要有以下几点： 此处只是介绍相关工作过程及概念，具体代码，网上一抓一大片，可以自己看。 1、管道： 管道通常分类两种，一种有名管道，一种无名管道无名管道：主要用于父子进程间的通信方式，主要的数据方式是一般是通过一个二维数组来进行通信，比如int pipefd[2]，pipefd[0]主要是用来读数据，pipefd[1
Linux 进程 | 进程间的通信方式
Jormungand_V的博客
08-13 481
文章目录 在之前的博客中讲过，虚拟空间出现的其中一个目的就是解决 进程没有独立性，可能访问同一块物理内存 的问题。因为这种独立性，进程之间无法直接进行通信，操作系统为了解决这种问题，提出了多种适用于不同情境下的通信方式： 数据传输：管道、消息队列 数据共享：共享内存 进程控制：信号量 ...
Linux进程间通信（文件方式）
万法归一
06-05 626
父进程和子进程在通信开始前要先关闭管道的未使用端，以确保从管道中读取的进程可以在写入程序关闭管道时检测到文件的结尾（返回0）。一旦进程完成通信并终止，普通管道就不再存在——只要该缓冲区中的数据不向磁盘刷新，数据就存在于进程的生命周期。管道的生命周期进程的生命周期。Linux中可以使用创建一个匿名管道： 运行结果 通过修改以上代码父子进程的读写时间，可以得出以下结论： 管道是面向字节流的单向通信信道，管道里只要缓冲区没满，就可以一直写入。 写端不写入或者写的速度小于读取的速度，读端会阻塞等待 实际写入时，
C++的创建命名管道（CreateNamedPipe）
热门推荐
sinat_31608641的博客
06-20 1万+
一、命名管道（Named Pipes） 管道（Pipe）实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另一进程就可以从管道的另一端将其读取出来。 匿名管道（Anonymous Pipes）是在父进程和子进程间单向传输数据的一种未命名的管道，只能在本地计算机中使用，而不可用于网络间的通信。 命名管道，顾名思义，这个管道肯定是有名字的。通过管道的名字来确保多个进程访问同一个管道。事实上，命名管道不仅可在同一台计算机的不同进程
进程间通信 - 命名管道实现
Steven Lei的博客
04-25 1186
命名管道概述 命名管道是通过网络来完成进程之间的通信的，命名管道依赖于底层网络接口， 其中包括有 DNS 服务，TCP/IP 协议等等机制，但是其屏蔽了底层的网络协议细节， 对于匿名管道而言，其只能实现在父进程和子进程之间进行通信，而对于命名管道而言， 其不仅可以在本地机器上实现两个进程之间的通信，还可以跨越网络实现两个进程之间的通信。 命名管道使用了 Windows 安全机制，因而命名
编写80个暗语，每个暗语用一个两位数代表（只使用1到9这9个数字），为了进一步提高保密性，又对数字做了顺序替换。本次的传递的信息是：“有萝卜1.43元、白菜0.89元、芹菜2.56元、韭菜3.82元、蒜3.78元”，设计一个python程序已经知道，顺序替换方式是平移4个位置（如：1替换为5，……，9替换为4）。请提取信息中的数字（不包含0），并还原成原始数字后，输出一个新的字符串。提示：由于数字可以直接做算数运算，因此不需要转换成Unicode编码，可以直接通过mod运算实现平移。
03-26
65： 一针见血 66： 三人成虎 67： 肆无忌惮 68： 方逢时艰 69： 毕恭毕敬 70： 潜龙勿用 71： 知音难觅 72： 切莫错过 73： 信口开河 74： 言传不如身教 75： 祸从天降 76： 水滴石穿 77： 一击即中 78： 四面出击 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值