基于Windows的进程互斥实现机制(生产者消费者模拟)

已于 2023-01-17 15:30:07 修改
阅读量535 收藏 3
点赞数 1
分类专栏： 操作系统 文章标签： qt 开发语言
于 2022-07-19 21:21:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myf_666/article/details/124813966
版权

作者：非妃是公主
专栏：《操作系统》
个性签：顺境不惰，逆境不馁，以心制境，万事可成。——曾国藩
在这里插入图片描述

专栏地址

《操作系统》专栏地址

专栏系列文章

操作系统复习01：引言

操作系统复习02：进程

操作系统复习03：输入输出系统

操作系统复习04：存储管理

操作系统复习05：文件系统

基于Windows的进程互斥实现机制(生产者消费者模拟)

Ubuntu操作系统+虚拟机virtualBox配置共享文件夹（实现主机和虚拟机之间文件资源共享）

文章目录

需求规格说明

基于QT Creator环境的多线程编程验证互斥的原理，通过使用semaphore，mutex等控制变量，实现对生产者消费者模型的真实模拟。调用了Qt多线程类库QThread进行实现，文件结构如下：其中PandC中主要写了生产者消费者相关函数，OSWork_1主要是前端界面显示的Qt类。
在这里插入图片描述

设计表示

生产者类的设计如下：

class Producer : public QThread
{
   Q_OBJECT
protected:
   void run();
signals:
   void pro(int c);
public:
   //线程退出的标识量
   volatile bool m_stop;
   Producer()
   {
       m_stop = false;      
   }
   //线程退出的接口函数，用户使用
   void stop()
   {
       m_stop = true;
       
   }
};

消费者的类设计如下：

class Consumer : public QThread
{
    Q_OBJECT
protected:
    void run();
signals:
    void con(int c);
public:
    //线程退出的标识量
    volatile bool m_stop;
    Consumer()
    {
        m_stop = false;
    }
    //线程退出的接口函数，用户使用
    void stop()
    {
        m_stop = true;
        
    }
};

详细设计表示

生产者访问缓冲区：主要通过线程锁unique_lock进行实现，它可以将信号量mutex锁住，在作用域范围内，只能一个线程访问临界区。其中，hcnum为缓冲区数量，sleep为休眠一定时间，通过它来控制生产者生产的速度。

void Producer::run() {
	int data1;
	while (!m_stop) {//通过外层循环，能保证生成用不停止
		if (c < hcnum) {//限流
			{
				data1 = rand();
				unique_lock<mutex> locker(mu);//锁
				q.push_front(data1);
				qDebug() << "存了" << data1 << endl;
				if (c == 1)
					cond.notify_one(); // 通知取
				++c;	
				
			}
			emit pro(c);
			Sleep(PSTime);
		}
	}
}

消费者访问缓冲区：功能和生产者正好互补，通过unique_lock,锁住信号量，确保生产者进程和消费者进程中，只能有一个留在缓冲区中。如果队列为空，那么说明消费者进程应该被阻塞进入阻塞队列，同时释放信号量，以便让生产者进程可以进入临界区生产。

void Producer::run() {
	int data1;
	while (!m_stop) {//通过外层循环，能保证生成用不停止
		if (c < hcnum) {//限流
			{
				data1 = rand();
				unique_lock<mutex> locker(mu);//锁
				q.push_front(data1);
				qDebug() << "存了" << data1 << endl;
				if (c == 1)
					cond.notify_one(); // 通知取
				++c;
			}
			emit pro(c);
			Sleep(PSTime);
		}
	}
}

“前后端”源文件间缓冲区数量通信：主要通过extern的方式，共享生产者生产速度和消费者消费速度这两个变量。

extern int PSTime = 1100;
extern int CSTime = 1100;

缓冲区数量显示：在创建生产者、消费者进程的时候，通过connect将concumer中的信号与前端OSWork_1中的显示函数关联到一起，进而实现生产者消费者进程对前端界面动态更新。

void OSWork_1::ReStart() {
  if (!producer) {
      producer = new Producer;
      connect(producer, &Producer::pro, this, &OSWork_1::display);
      producer->start();
  }
  if (!consumer) {
      consumer = new Consumer;
      connect(consumer, &Consumer::con, this, &OSWork_1::display);
      consumer->start();
  }
}

缓冲区数量显示主要通过10个label，根据不同颜色进行不同的显示。核心代码如下：
在这里插入图片描述

软件运行后，主界面如下： 在这里插入图片描述

源代码

//OSWork_1.h
#pragma once
#pragma execution_character_set("utf-8")
#include <QtWidgets/QMainWindow>
#include <qpalette.h>
#include "ui_OSWork_1.h"
#include"PandC.h"
#include <qpushbutton.h>
#include <qdebug.h>

class OSWork_1 : public QMainWindow
{
    Q_OBJECT
public:
    QPalette pe1;
    QPalette pe2;
    Producer* producer;
    Consumer* consumer;
    OSWork_1();
    void display(int c);
    void ReStart();
    void End();
    void add_p();
    void sub_p();
    void add_c();
    void sub_c();
    ~OSWork_1();
private:
    Ui::OSWork_1Class ui;
};

//PandC.h
#pragma once
#pragma execution_character_set("utf-8")
#include <QThread>
#include <QDebug>
#include<qpalette.h>
#include <deque>
#include <mutex>
#include <condition_variable>
#include<Windows.h>
#include <qlabel.h>

class Producer : public QThread
{
    Q_OBJECT
protected:

    void run();
signals:
    void pro(int c);
public:
    //线程退出的标识量
    volatile bool m_stop;
    Producer()
    {
        m_stop = false;
    }
    //线程退出的接口函数，用户使用
    void stop()
    {
        m_stop = true;
    }

};

class Consumer : public QThread
{
    Q_OBJECT
protected:
    void run();
signals:
    void con(int c);
public:
    //线程退出的标识量
    volatile bool m_stop;
    Consumer()
    {
        m_stop = false;
    }
    //线程退出的接口函数，用户使用
    void stop()
    {
        m_stop = true;
    }
};

//OSWork_1.cpp
#include "OSWork_1.h"
extern int PSTime;
extern int CSTime;

void OSWork_1::display(int c) {
    ui.label_1->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_2->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_3->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_4->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_5->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_6->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_7->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_8->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_9->setAutoFillBackground(true);  //一定要这句，否则不行
    ui.label_10->setAutoFillBackground(true);  //一定要这句，否则不行

    switch (c)
    {
    case 0:
        ui.label_1->setPalette(pe2);        
        ui.label_2->setPalette(pe2);
        ui.label_3->setPalette(pe2);
        ui.label_4->setPalette(pe2);
        ui.label_5->setPalette(pe2);
        ui.label_6->setPalette(pe2);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 1:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe2);
        ui.label_3->setPalette(pe2);
        ui.label_4->setPalette(pe2);
        ui.label_5->setPalette(pe2);
        ui.label_6->setPalette(pe2);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 2:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe2);
        ui.label_4->setPalette(pe2);
        ui.label_5->setPalette(pe2);
        ui.label_6->setPalette(pe2);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 3:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe2);
        ui.label_5->setPalette(pe2);
        ui.label_6->setPalette(pe2);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 4:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe2);
        ui.label_6->setPalette(pe2);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 5:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe1);
        ui.label_6->setPalette(pe2);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 6:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe1);
        ui.label_6->setPalette(pe1);
        ui.label_7->setPalette(pe2);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 7:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe1);
        ui.label_6->setPalette(pe1);
        ui.label_7->setPalette(pe1);
        ui.label_8->setPalette(pe2);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 8:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe1);
        ui.label_6->setPalette(pe1);
        ui.label_7->setPalette(pe1);
        ui.label_8->setPalette(pe1);
        ui.label_9->setPalette(pe2);
        ui.label_10->setPalette(pe2);
        break;
    case 9:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe1);
        ui.label_6->setPalette(pe1);
        ui.label_7->setPalette(pe1);
        ui.label_8->setPalette(pe1);
        ui.label_9->setPalette(pe1);
        ui.label_10->setPalette(pe2);
        break;
    case 10:
        ui.label_1->setPalette(pe1);
        ui.label_2->setPalette(pe1);
        ui.label_3->setPalette(pe1);
        ui.label_4->setPalette(pe1);
        ui.label_5->setPalette(pe1);
        ui.label_6->setPalette(pe1);
        ui.label_7->setPalette(pe1);
        ui.label_8->setPalette(pe1);
        ui.label_9->setPalette(pe1);
        ui.label_10->setPalette(pe1);
        break;
    default:
        break;
    }
    ui.label_pnum->setText("生产者数量：" + QString::number(16 - PSTime / 100));
    ui.label_cnum->setText("消费者数量：" + QString::number(16 - CSTime / 100));
}

OSWork_1::OSWork_1()
    : QMainWindow()
{
    ui.setupUi(this);
    this->setWindowTitle("生产者消费者模拟器");
    producer = nullptr;
    consumer = nullptr;
    //设置黑底红字
    pe1.setColor(QPalette::Background, Qt::black);
    pe1.setColor(QPalette::WindowText, Qt::red);
    pe2.setColor(QPalette::Background, Qt::white);
    pe2.setColor(QPalette::WindowText, Qt::red);
    //ui.label_1->setPalette(pe1);
    connect(producer, &Producer::pro, this, &OSWork_1::display);
    connect(consumer, &Consumer::con, this, &OSWork_1::display);
    connect(ui.pushButton_end, &QPushButton::clicked, this, &OSWork_1::End);
    connect(ui.pushButton_start, &QPushButton::clicked, this, &OSWork_1::ReStart);
    connect(ui.pushButton_addp, &QPushButton::clicked, this, &OSWork_1::add_p);
    connect(ui.pushButton_subp, &QPushButton::clicked, this, &OSWork_1::sub_p);
    connect(ui.pushButton_addc, &QPushButton::clicked, this, &OSWork_1::add_c);
    connect(ui.pushButton_subc, &QPushButton::clicked, this, &OSWork_1::sub_c);
}

OSWork_1::~OSWork_1() {
    End();
}

void OSWork_1::End() {
    if (producer && !producer->m_stop) {
        producer->m_stop = true;
        producer->wait();
        delete producer;
        producer = nullptr;
    }
    if (consumer && !consumer->m_stop) {
        consumer->m_stop = true;
        consumer->wait();
        consumer->quit();
        delete consumer;
        consumer = nullptr;
    }
}

void OSWork_1::ReStart() {
    if (!producer) {
        producer = new Producer;
        connect(producer, &Producer::pro, this, &OSWork_1::display);
        producer->start();
    }
    if (!consumer) {
        consumer = new Consumer;
        connect(consumer, &Consumer::con, this, &OSWork_1::display);
        consumer->start();
    }
}

void OSWork_1::add_p() {
    if (producer) {
        if (PSTime > 600)
            PSTime -= 100;
        qDebug() << "PSTime时长为：" << PSTime;
    }
}

void OSWork_1::sub_p() {
    if (producer) {
        if (PSTime < 1500)
            PSTime += 100;
        qDebug() << "PSTime时长为：" << PSTime;
    }
}

void OSWork_1::add_c() {
    if (consumer) {
        if (CSTime > 600)
            CSTime -= 100;
        qDebug() << "CSTime时长为：" << CSTime;
    }
}

void OSWork_1::sub_c() {
    if (consumer) {
        if (CSTime < 1500)
            CSTime += 100;
        qDebug() << "CSTime时长为：" << CSTime;
    }
}
```java
//PandC.cpp
#include "PandC.h"
using namespace std;
class OSWork_1;
deque<int> q;
mutex mu;
condition_variable cond;
int c = 0;//缓冲区的产品个数
extern int PSTime = 1100;
extern int CSTime = 1100;
int hcnum = 10;
void Producer::run() {
	int data1;
	while (!m_stop) {//通过外层循环，能保证生成用不停止
		if (c < hcnum) {//限流
			{
				data1 = rand();
				unique_lock<mutex> locker(mu);//锁
				q.push_front(data1);
				qDebug() << "存了" << data1 << endl;
				if (c == 1)
					cond.notify_one(); // 通知取
				++c;
			}
			emit pro(c);
			Sleep(PSTime);
		}
	}
}

void Consumer::run() {
	int data2;//data用来覆盖存放取的数据
	while (!m_stop) {
		{
			unique_lock<mutex> locker(mu);
			if (q.empty())
				cond.wait(locker); //wati()阻塞前先会解锁,解锁后生产者才能获得锁来放产品到缓冲区；生产者notify后，将不再阻塞，且自动又获得了锁。
			data2 = q.back();//取的第一步
			q.pop_back();//取的第二步
			qDebug() << "取了" << data2 << endl;
			--c;
		}
		emit con(c);
		Sleep(CSTime);
	}
}

//main.cpp
#include "OSWork_1.h"
#include <QtWidgets/QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    OSWork_1 w;
    w.show();
    return a.exec();
}

源代码下载地址

CSDN下载链接：https://download.csdn.net/download/myf_666/86245828
github下载链接：https://github.com/ManYufei888/Producer-consumer-process-simulation/tree/main

Cherries Man
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++实现生产与消费者模型
01-27
在计算机科学中，生产者-消费者...在实际应用中，生产者-消费者模型可以广泛应用于数据缓存、网络I/O、多进程通信等领域，是并发编程中不可或缺的模型。理解和熟练掌握这种模型，有助于编写出高效、安全的多线程程序。
vc生产者消费者问题模拟源码
11-06
本源码是基于MFC（Microsoft Foundation Classes）实现的一个基础生产者-消费者问题模拟，这表明它是用C++编写，并利用了MFC库来构建用户界面和处理多线程。MFC是一个由微软提供的类库，用于简化Windows应用程序开发...
Qt线程同步——生产者消费者模式（QSemaphore）
百叶书的博客
09-16 1044
生产者消费者模式 在实际的软件开发过程中，经常碰到一个场景：某个模块负责产生数据，这些数据由另一个模块负责处理。 产生数据的模块称为生产者，处理数据的模块称为消费者。 在生产者和消费者之间有个中介，称为缓冲区。 缓冲区的作用： （1）解耦：使生产者和消费者之间不形成直接依赖，耦合降低； （2）并发：生产者和消费者成为两个并发独立主体。生产者将数据丢至缓冲区，就去生产下一个数据，不依赖消费者的处理速度。 （3）支持忙闲不均。 ...
【生产者-消费者问题】Windows线程的互斥与同步
有为肥宅的博客
07-13 1464
【生产者-消费者问题】Windows线程的互斥与同步（操作系统课设作业）
Qt入门练习项目——生产者消费者模型（多线程与自定义信号）
记录学习
08-01 1917
通过生产者消费者模型了解Qt的多线程的使用
进程同步互斥之生产者与消费者问题
jungleirim的博客
10-09 1386
生产者消费者问题是一个互斥、同步的综合问题。对于初学者来说最难的是发现题目中隐含的两对同步关系。有时候是消费者需要等待生产者生产，有时候是生产者要等待消费者消费，这是两个不同的“一前一后问题”，因此也需要设置两个同步信号量。
QWaitCondition源码解析（暨生产者消费者线程分析）
pk0127的博客
08-30 303
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、官方自带生产者消费者源码分析二、疑问及源码解析1、疑点：互斥量加锁不释放，难道不死锁么？2.疑点：Qt会重复unlock么？三、总结 前言 此记录为刷leetcode 过程中复习Qt多线程的意外收获，也是对自己使用Qt过程中疑问的回答 一、官方自带生产者消费者源码分析
操作系统课程设计报告--基于Windows进程互斥实现机制.doc
09-28
本报告中，我们设计和实现了一种基于Windows进程互斥实现机制的算法，通过使用Semaphore和Mutex等控制元素，实现了对生产者消费者模型的真实模拟。该算法可以应用于各种多线程编程场景，提高系统的并发性和效率。 ...
jchc.rar_tearshmj_生产者_生产者-消费者问题 c++ _生产者和消费者_生产者消费者
09-23
在本项目中，我们将探讨这个问题，并以C++语言为基础，创建一个在Windows 2000环境下运行的控制台应用程序，通过多线程模拟生产者和消费者的行为。 首先，我们要理解生产者-消费者模型的基本概念。在这个模型中，...
实现生产者消费者问题和实现银行家算法的课程设计.doc
05-06
在操作系统课程设计中，生产者消费者问题和银行家算法都是经典的进程同步问题。本设计将对这两个问题进行深入分析和实现。 一、生产者消费者问题 生产者消费者问题是经典的进程同步问题，问题描述参见教材第 36 页...
消费者与生产者（windows下）
04-26
此次试验是操作系统第七版de附加试验，但由于书上已经给出了关于这个问题的具体思路，这段代码只是根据那个思路写出来的产品。仅供参考。
消费者与生产者
07-30
操作系统生产者和消费者课程设计模拟设计，使用mfc对话框
操作系统课程设计-Windows 线程的互斥和同步
最新发布
qq_63306482的博客
01-17 1185
本实验为课设内容，博客内容为部分报告内容，仅为大家提供参考，请勿直接抄袭，另外，本次实验所用平台是dev c++5.11。
qt 生产者-消费者模型学习
weixin_42460987的博客
09-08 2107
我参考的网址：https://mp.weixin.qq.com/s/wh9RLbDwP1AoNy50i4WEdg https://www.cnblogs.com/chentingk/p/6497107.html 生产者-消费者模型 生产者消费者模型的实现 生产者是一堆线程，消费者是另一堆线程，内存缓冲区可以使用List数组队列，数据类型只需要定义一个简单的类就好。关键是如何处理多线程之间的协作。这其实也是多线程通信的一个范例。 　　在这个模型中，最关键就是内存缓冲区为空的时候消费者必须等待，而内存缓冲区满
线程的互斥和同步（5）- Windows的信号量Semaphore
不会飞的纸飞机的博客
02-19 1121
信号量也是进程间同步常用的手段之一。举个例子，比如我们要去餐馆吃饭，这家餐馆一共有4个位置，我们一共是6个人。那么就会4个人先去吃饭，等他们吃完了，剩下的2个人再去吃饭，如果再来人则需要判断是否有空位置，如果有直接坐下吃饭，如果没有则需要等待。 这里的每一个顾客就相当于一个线程，而通知你排队叫号进餐的那个服务员就是我们的信号量。信号量可以有效的保证我们多个线程并发执行。 对于信号量，我们经常使用的...
操作系统课设——Windows 的互斥与同步
qq_53581188的博客
07-23 1765
一、实验目的 (1) 回顾操作系统进程、线程的有关概念，加深对 Windows 线程的理解。 (2) 了解互斥体对象，利用互斥与同步操作编写生产者-消费者问题的并发程序，加深对 P (即semWait)、V(即 semSignal)原语以及利用 P、V 原语进行进程间同步与互斥操作的理解。 二、实验内容和步骤 生产者消费者问题 步骤 1：创建一个“Win32 Consol Application”工程，然后拷贝程序，编译成可执行文件。 步骤 2：在“命令提示符”窗口运行步骤 1 中生成的可执行文件，列出运行
windows实现进程互斥
奋斗的伙计
12-27 1546
比较简单，但很实用的小文章 通过互斥量实现进程的互斥 在visual studio下测试过，是成功的 code： -------------------------------------------------------------------------------------------------------------------------------------------
操作系统进程互斥的实现
EDG_Clearlove_7的博客
10-30 1600
操作系统各种互斥资源访问的方法介绍
生产者-消费者同步互斥问题
Charming的博客
11-06 1549
信号量机制-进程同步解决方法3 用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而实现进程互斥（进程对临界资源的单独访问），进程同步（进程对临界资源的访问顺序）问题 信号量听名字，好像是个跟信号、电气沾边的东西，其实信号量就是一个变量，用来表示系统资源数量，比如打印机的数量，也可以理解为操作系统层面的变量，每个进程共享 注意信号量可以是整型变量，也可以是个结构体变量 原语就是一种特殊的程序段，它的执行是一气呵成，不可被中断的，比如A用户先检查厕所没人，然后进去上锁，这两个步骤是连贯的；试想如
生产者消费者算法实验：互斥与同步的模拟实现
- 功能：模拟生产者和消费者进程的互动，以及他们对缓冲区的并发访问，确保在资源不足时进行适当的阻塞和唤醒，以实现进程间同步。 2. **概要设计** - 设计思路：通过创建一个共享缓冲区，设置两个线程，生产者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cherries Man

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

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

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

抵扣说明：

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

余额充值