对于用Posix信号量解决读者-写者问题的小研究

最新推荐文章于 2011-11-14 17:51:28 发布
最新推荐文章于 2011-11-14 17:51:28 发布
阅读量460 收藏 1
点赞数
分类专栏： 读书笔记 文章标签： null join struct file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tricky1997/article/details/6893430
版权


单缓冲区



问题描述：

        共享缓冲区为环形，为NBUFF个元素的int数组。若干个生产者，若干个消费者在进行读写操作。



一个读者，一个写者：

需要三种信号量：
        mutex二值信号量，保护读和写操作。可以用互斥锁代替。
        nempty信号量，初始化数量为空槽数量（NBUFF）。
        nstored信号量，初始化数量为0。

主函数：
        输入：nitems
        初始化三个信号量。create两个线程，然后join它们。

produce：
for( i = 0 ; i < nitems ; ++i)
{
        等待空信号量；
        等待mutex；
        生产；
        释放mutex；
        等待空信号量；
}

consume：
for( i = 0 ; i< nitems;++i)
{
        等待nstored信号量；
        等待mutex；
        消费；
        释放mutex；
        释放nstored信号量；
}

代码：


#include "../common.h" 

#define NBUFF 10 
#define SEM_MUTEX "mutex" 
#define SEM_NEMPTY "nempty" 
#define SEM_NSTORED "nstored" 

#define FILE_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 

struct { 
  int buff[NBUFF]; 
  sem_t *mutex, *nempty, *nstored; 
} shared; 

int nitems; 

void* produce(void*); 
void* consume(void*); 

int main(int argc, char** argv) 
{ 
  
  pthread_t produce_tid, consume_tid; 

  if( argc!=2 ) 
    err_exit("usage: prodcons1 <nitems>"); 

  nitems = atoi(argv[1]); 

  sem_unlink(SEM_MUTEX); 
  sem_unlink(SEM_NEMPTY); 
  sem_unlink(SEM_NSTORED); 

  if( (shared.mutex = sem_open(SEM_MUTEX, O_CREAT|O_RDWR, FILE_MODE, 1)) == SEM_FAILED) 
    err_exit("sem_open"); 
  if( (shared.nempty = sem_open(SEM_NEMPTY, O_CREAT|O_RDWR, FILE_MODE, NBUFF)) == SEM_FAILED) 
    err_exit("sem_open"); 
  if( (shared.nstored = sem_open(SEM_NSTORED, O_CREAT|O_RDWR, FILE_MODE, 0)) == SEM_FAILED) 
    err_exit("sem_open"); 

  pthread_create(&produce_tid, NULL, produce, NULL); 
  
  pthread_create(&consume_tid, NULL, consume, NULL); 

  pthread_join(produce_tid, NULL); 
  pthread_join(consume_tid, NULL); 
  
  sem_unlink(SEM_MUTEX); 
  sem_unlink(SEM_NEMPTY); 
  sem_unlink(SEM_NSTORED); 
  exit(0); 
} 


void* produce( void* val) 
{ 
  int i; 

  for( i = 0 ; i < nitems ; ++i) 
    { 
      sem_wait(shared.nempty); 
      sem_wait(shared.mutex); 
      printf("put %4d\n", i); 
      shared.buff[i%NBUFF] = i; 
      sem_post(shared.mutex); 
      sem_post(shared.nstored); 
    } 
  return NULL; 
} 

void* consume(void* val) 
{ 
  int i; 

  for( i = 0 ; i < nitems ; ++i) 
    { 
      sem_wait(shared.nstored); 
      printf("get nstored\n"); 
      sem_wait(shared.mutex); 
      if( shared.buff[i%NBUFF] != i) 
	fprintf(stderr, "buff[%d] = %d\n", i, shared.buff[i%NBUFF]); 
      sem_post(shared.mutex); 
      sem_post(shared.nempty); 
    } 

  return NULL; 
}

分析：

        在这个例子中，mutex不是必须的，因为消费和生产的过程完全互不影响。但，一般情况下是需要的，建议一直加上。
        注意加锁顺序，否则可能死锁。
        这个代码里使用的是有名信号量，实际上使用基于内存的信号量还更简单点。


多个生产者，一个消费者


        所需要的信号量不变，mutex，nstored和nempty足以应付多个生产者的情况。
        需要nput和nval来标明下一个生产者要填入的位置和数据。

主函数：
        输入nitems、nthreads；
        生成nthreads个生产者线程；
        生成一个消费者线程；
        等待他们结束；
        输出每个线程的统计数量。

produce：
while(1)
{
        等待nempty和mutex；
        检查是否已经生产nitems个项；
        没有的话，挂出mutex和nempty。退出。
        生产；
        挂出nstored和mutex
        增加自己的生产数量统计；
}

consume:
for(i=0;i<nitems;++i)
{
        等待nstored和mutex；
        检查是否正确；
        挂出nempty和mutex；
}

代码（使用了基于内存的信号量）： 


#include "../common.h"

#define NBUFF 10
#define MAXNTHREADS 100

struct {
  int buff[NBUFF];
  int nput;
  int nval;
  sem_t mutex, nempty, nstored;
} shared;

int nitems;

void* produce(void*);
void* consume(void*);

int main(int argc, char** argv)
{
  
  pthread_t produce_tid[MAXNTHREADS], consume_tid;
  int nthreads, i;
  int count[MAXNTHREADS];

  if( argc!=3 )
    err_exit("usage: prodcons1 <nitems> <threads>");

  nitems = atoi(argv[1]);
  nthreads = (atoi(argv[2]) > MAXNTHREADS)? MAXNTHREADS : atoi(argv[2]);

  if( (sem_init(&shared.mutex, 0, 1)) == -1)
    err_exit("sem_init");
  if( (sem_init(&shared.nempty, 0, NBUFF)) == -1)
    err_exit("sem_init");
  if( (sem_init(&shared.nstored, 0, 0)) == -1)
    err_exit("sem_init");

  for( i = 0 ; i < nthreads ; ++i)
    {
      count[i] = 0;      
      pthread_create(&produce_tid[i], NULL, produce, &count[i]);
    }

  pthread_create(&consume_tid, NULL, consume, NULL);
  pthread_join(consume_tid, NULL);

  for( i = 0 ; i < nthreads ; ++i)
    {
      pthread_join(produce_tid[i], NULL);
      printf("count[%d] = %d\n", i, count[i]);
    }

  exit(0);
}


void* produce( void* val)
{

  while(1)
    {
      sem_wait(&shared.nempty);
      sem_wait(&shared.mutex);
      if(shared.nput >= nitems)
	{
	  sem_post(&shared.mutex);
	  sem_post(&shared.nempty);
	  return NULL;
	}
      shared.buff[(shared.nput++)%NBUFF] = shared.nval++;
      sem_post(&shared.mutex);
      sem_post(&shared.nstored);
      ++*((int*)val);
    }
  return NULL;
}

void* consume(void* val)
{
  int i;

  for( i = 0 ; i < nitems ; ++i)
    {
      sem_wait(&shared.nstored);
      sem_wait(&shared.mutex);
      if( shared.buff[i%NBUFF] != i)
	fprintf(stderr, "buff[%d] = %d\n", i, shared.buff[i%NBUFF]);
      sem_post(&shared.mutex);
      sem_post(&shared.nempty);
    }

  return NULL;
}


分析：

        能同时获得nempty的生产者有多个，但能获得mutex的只有一个。
        生产者在正常生产结束后和已达到要求退出时，都要挂出mutex，但另一个挂出的分别为nstored和nempty。


多个生产者，多个消费者


当消费者变为多个时，需要类似于nput和nval的变量nget和ngetval来同步消费者。

主函数：
        输入nitems，nthreads，nconsumers；
        产生nthreads个生产者线程，nconsumers个消费者线程；
        等待他们结束；
        分别输出统计数量。

produce：
while(1)
{
        等待nempty和mutex；
        检查是否已经生产nitems个项；
        是的话，挂出mutex和nempty以及NSTORED！。退出。
        生产；
        挂出nstored和mutex
        增加自己的生产数量统计；
}

consume:
for(i=0;i<nitems;++i)
{
        等待nstored和mutex；
        检查是否已经检查了nitems个项；
        是的话，挂出mutex和nstored。退出。
        检查是否正确；
        挂出nempty和mutex；
        增加自己的消费数量统计；
}

代码： 

#include "../common.h"

#define NBUFF 10
#define MAXNTHREADS 100

struct {
  int buff[NBUFF];
  int nput;
  int nval;
  int nget;
  int ngetval;
  sem_t mutex, nempty, nstored;
} shared;

int nitems;

void* produce(void*);
void* consume(void*);

int main(int argc, char** argv)
{
  
  pthread_t produce_tid[MAXNTHREADS], consume_tid[MAXNTHREADS];
  int nthreads, nconsumers, i;
  int count[MAXNTHREADS], count2[MAXNTHREADS];

  if( argc!=4 )
    err_exit("usage: prodcons1 <nitems> <threads> <nconsumers>");

  nitems = atoi(argv[1]);
  nthreads = (atoi(argv[2]) > MAXNTHREADS)? MAXNTHREADS : atoi(argv[2]);
  nconsumers = (atoi(argv[3]) > MAXNTHREADS)? MAXNTHREADS : atoi(argv[3]);

  if( (sem_init(&shared.mutex, 0, 1)) == -1)
    err_exit("sem_init");
  if( (sem_init(&shared.nempty, 0, NBUFF)) == -1)
    err_exit("sem_init");
  if( (sem_init(&shared.nstored, 0, 0)) == -1)
    err_exit("sem_init");

  for( i = 0 ; i < nthreads ; ++i)
    {
      count[i] = 0;      
      pthread_create(&produce_tid[i], NULL, produce, &count[i]);
    }

  for( i = 0 ; i < nconsumers ; ++i)
    {
      count2[i] = 0;
      pthread_create(&consume_tid[i], NULL, consume, &count2[i]);
    }

  for( i = 0 ; i < nconsumers ; ++i)
    {
      pthread_join(consume_tid[i], NULL);
      printf("count2[%d] = %d\n",i, count2[i]);
    }

  for( i = 0 ; i < nthreads ; ++i)
    {
      pthread_join(produce_tid[i], NULL);
      printf("count[%d] = %d\n", i, count[i]);
    }

  exit(0);
}


void* produce( void* val)
{

  while(1)
    {
      sem_wait(&shared.nempty);
      sem_wait(&shared.mutex);
      if(shared.nput >= nitems)
	{
	  sem_post(&shared.nstored);
	  sem_post(&shared.mutex);
	  sem_post(&shared.nempty);
	  return NULL;
	}
      shared.buff[(shared.nput++)%NBUFF] = shared.nval++;
      sem_post(&shared.mutex);
      sem_post(&shared.nstored);
      ++*((int*)val);
    }
  return NULL;
}

void* consume(void* val)
{

  while(1)
    {
      sem_wait(&shared.nstored);
      sem_wait(&shared.mutex);
      if( shared.nget >= nitems)
	{
	  sem_post(&shared.mutex);
	  sem_post(&shared.nstored);
	  return NULL;
	}
      if( shared.buff[(shared.nget++)%NBUFF] != shared.ngetval++)
	fprintf(stderr, "buff[%d] = %d\n", shared.nget-1, shared.buff[(shared.nget-1)%NBUFF]);
      sem_post(&shared.mutex);
      sem_post(&shared.nempty);

      ++*((int*)val);
    }

  return NULL;
}

分析：

        与之前的不同，produce函数里的if语句内，多了一行sem_post(&shared.nstored)。看上去，这个不应该出现。这行代码的作用是为了使消费者结束。设想，最后的消费者读完最后一个item后，循环回去又会等待nstored信号量，可这时生产者已经生产完毕，不会再多挂出一个nstored信号量。于是，生产者里退出时的这个sem_post(&shared.nstored)，为了多给出至少一个信号量使消费者退出（消费者拿到后，发现都读完了，进入if又挂出了nstored。实际上，这个nstored多一个就可以）。

        一个基本原则，生产消费问题的正常终止状态和开始状态的信号量是一样的。




多缓冲区



问题描述：

        在文件复制或显示的程序中，常见的这种读写问题： while( fgets()) fputs()；
        当使用一个缓冲区时，即使读写分开线程，由于缓冲区共享也不会加快。
        使用NBUFF个缓冲区，每个缓冲区NBUFFSIZE大小。一个写者，一个读者，来回向NBUFF个缓冲区上放数据取数据。


一个读者，一个写者


需要的信号量：

        nempty信号量，初始化数量为缓冲区数量NBUFF。
        nstored信号量，初始化数量为0，代表开始时没有缓冲区有数据。
        mutex二值信号量，在这个例子中，由于只有一个读一个写，而且读和写的操作相互独立，mutex不需要。如果，涉及到链表的增加删除，就需要mutex在读和写进行链表修改时同步。

main：
        打开要读入的文件；
        初始化信号量；
        生成读和写线程，并等待其结束。

produce:
while(1)
{
        等待nempty信号量；
        读取文件，填充下一个缓冲区；
        如果读到文件末尾，那么挂出一个额外的nstored信号量（原因同多读多写的例子），退出；
        挂出nstored信号量
}

consume:
while(1)
{
        等待nstored信号量；
        查看下一个缓冲区；
        如果缓冲区的字节数为0，退出；
        将缓冲区的数据写到要输出的fd；
        挂出nempty信号量；
}

代码： 
#include "../common.h"

#define NBUFF 8
#define NBUFFSIZE 4096

struct {
  struct {
    char data[NBUFFSIZE];
    int  n;
  } buff[NBUFF];
  sem_t nempty, nstored;
} shared;

int fd;

void* produce(void*);
void* consume(void*);

int main( int argc, char** argv)
{
  pthread_t tid_produce, tid_consume;

  if(argc != 2)
    err_exit("usage: mycat2 <filename>");

  if( (fd=open(argv[1], O_RDWR)) == -1)
    err_exit("open");

  if( sem_init(&shared.nempty, 0, NBUFF) == -1)
    err_exit("sem_init");
  if( sem_init(&shared.nstored, 0, 0) == -1)
    err_exit("sem_init");

  pthread_create(&tid_produce, NULL, produce, NULL);
  pthread_create(&tid_consume, NULL, consume, NULL);

  //printf("create threads OK!\n");

  pthread_join(tid_consume, NULL);
  pthread_join(tid_produce, NULL);
  
  exit(0);
}

void* produce (void* val)
{
  int i=0;

  while(1)
    {
      sem_wait(&shared.nempty);
      //printf("get nempty\n");
      shared.buff[i].n = read(fd, shared.buff[i].data, NBUFFSIZE);
      if(shared.buff[i].n == 0 )
	{
	  sem_post(&shared.nstored);
	  return NULL;
	}
      i = (i+1) % NBUFF;
      
      sem_post(&shared.nstored);
    }
  return NULL;
}

void* consume(void* val)
{
  int i = 0 ; 
  
  while(1)
    {
      sem_wait(&shared.nstored);
      
      if(shared.buff[i].n == 0 || shared.buff[i].n == -1)
	return NULL;

      write(STDOUT_FILENO, shared.buff[i].data, shared.buff[i].n);
      i = (i+1)%NBUFF;

      sem_post(&shared.nempty);
    }
  return NULL;
}

分析：
        如前所述，单纯的将读和写分开两个线程总时间并不能获得任何速度上的优势。
        这个例子没有使用mutex，因为读和写唯一而且互不相干。如果使用链表方式管理缓冲区，读的时候新分配一个缓冲区并添加到链表，写的时候去掉一个链表，这样的话我们就需要加入mutex防止交叉操作对链表指针的破坏。
tricky1997
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReadWriteLock:使用 POSIX 信号量用 C 编写的读者首选读写锁
06-29
这是通过使用 POSIX 信号量和“隐藏”结构声明来实现的，以避免滥用提供的 API。 这个锁是reader-preferred ，这意味着一个 writer 必须等待每个 reader 完成才能获得锁。 有关更多信息，请参见。 我目前正在尝试使...
进程同步模拟设计--读者和写者问题
01-28
除了信号量，还可以使用管程（Monitor）或其他高级同步原语来解决读者和写者问题。管程是一种在并发环境中提供互斥和同步的结构化方法，它包含一个或多个过程和一个互斥变量。在管程中，读者和写者进程可以作为过程...
linux下C语言实现读者写者（写者优先）
04-18
下面是一段简单的C代码框架，展示了如何使用信号量实现读者写者问题的写者优先版本： ```c #include #include #include sem_t reader_count; sem_t writer_lock; void* reader_thread(void* arg) { // 读者...
操作系统课程设计-实现读者写者(Reader-Writer Problem)问题
06-29
解决读者写者问题需要设计合适的数据结构和模块，例如读者和写者的线程函数、共享资源的保护机制、信号量的使用等。数据结构和模块的设计需要考虑到读者和写者的并发访问顺序、共享资源的保护和线程之间的同步机制等...
有限缓冲区生产者消费者和读进程优先的读者写者问题
12-14
在Linux C环境中，有限缓冲区的生产者-消费者和读者-写者问题是多线程或进程间通信（IPC，Interprocess Communication）的经典示例。这些问题是并发编程中的核心概念，用于解决多个进程如何共享资源而不会产生数据...
nginx简单配置及使用
11-14 5893
最近感觉nginx各种火，大有取代apache的趋势，于是学一学，虚拟机里搭个服务器练一练。 学了一下午，略有心得，记下来大家一起分享。 安装过程不做重点：nginx安装最简单，tomcat和jdk安装加环境变量，php(fastcgi)安装最麻烦，后文会给出部分说明。   概要 这篇文章将包括以下内容： nginx查找虚拟主机原理的简单介绍； 通过不同ip访问同一台服务器到达不同的
nginx的简单配置
11-14 201
最近感觉nginx各种火，大有取代apache的趋势，于是学一学，虚拟机里搭个服务器练一练。 学了一下午，略有心得，记下来大家一起分享。 安装过程不做重点：nginx安装最简单，tomcat和jdk安装加环境变量，php(fastcgi)安装最麻烦，后文会给出部分说明。   概要 这篇文章将包括以下主要内容： nginx查找虚拟主机原理的简单介绍； 通过不同ip访问同一台服务器到达不
基于卷积神经网络的语音识别声学模型的研究
08-04
【项目资源】：包含前端、后端、移动开发、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源，毕业设计等各种技术项目的源码。包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：适用于希望学习不同技术领域的初学者或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。鼓励下载和使用，并欢迎大家互相学习，共同进步。
VCD租借管理系统VB（源程序+论文）.rar
08-04
VCD租借管理系统VB（源程序+论文）
嗖嗖移动大厅（Java）
08-04
嗖嗖移动大厅源码
android-studio-2022.3.1.22-windows.zip.001
08-04
android-studio-2022.3.1.22-windows.zip.001 参考文档： https://blog.csdn.net/xzzteach/article/details/140911515 android-studio-2022.3.1.22-windows.zip.001 https://download.csdn.net/download/xzzteach/89614079 android-studio-2022.3.1.22-windows.zip.002 https://download.csdn.net/download/xzzteach/89614082 https://blog.csdn.net/xzzteach/article/details/140913786 【Android Studio】2022.3.1.22-windows版本（不要太新拒绝过老）安装使用一条龙教程（JDK1.8.0_201、API28(9)、gradle-6.5-all）
[毕业设计]VB+ACCESS大型机房学生上机管理系统设计与实现(源代码+论文).zip
08-04
[毕业设计]VB+ACCESS大型机房学生上机管理系统设计与实现(源代码+论文)
面包旅行.rar
08-04
小程序的设计源码通常包含多个文件和文件夹，组织结构清晰，以便开发者能够快速上手并进行定制化开发。主要文件和文件夹包括： 页面文件夹：存放小程序的各个页面，每个页面通常由.wxml、.wxss、.js和.json文件组成。WXML文件负责页面的结构，类似于HTML；WXSS文件负责样式，类似于CSS；JS文件负责页面的逻辑和交互；JSON文件用于页面的配置，如导航栏标题等。 组件文件夹：存放可复用的UI组件。组件与页面类似，也由.wxml、.wxss、.js和.json文件组成。通过组件化设计，可以提高代码的复用性和维护性，减少重复工作。 静态资源文件夹：存放图片、音频、视频等静态资源，便于在小程序中引用。这些资源通常放在一个名为assets或static的文件夹中。 配置文件：小程序的根目录下通常有一个app.json文件，用于全局配置，如页面路径、导航栏样式、底部Tab栏等。此外，还有app.wxss和app.js文件，分别用于全局样式和全局逻辑。 工具文件夹：存放一些工具函数和库文件，便于在小程序中调用。这些文件通常放在一个名为utils的文件夹中。
艺术.rar
08-04
小程序的设计源码通常包含多个文件和文件夹，组织结构清晰，以便开发者能够快速上手并进行定制化开发。主要文件和文件夹包括： 页面文件夹：存放小程序的各个页面，每个页面通常由.wxml、.wxss、.js和.json文件组成。WXML文件负责页面的结构，类似于HTML；WXSS文件负责样式，类似于CSS；JS文件负责页面的逻辑和交互；JSON文件用于页面的配置，如导航栏标题等。 组件文件夹：存放可复用的UI组件。组件与页面类似，也由.wxml、.wxss、.js和.json文件组成。通过组件化设计，可以提高代码的复用性和维护性，减少重复工作。 静态资源文件夹：存放图片、音频、视频等静态资源，便于在小程序中引用。这些资源通常放在一个名为assets或static的文件夹中。 配置文件：小程序的根目录下通常有一个app.json文件，用于全局配置，如页面路径、导航栏样式、底部Tab栏等。此外，还有app.wxss和app.js文件，分别用于全局样式和全局逻辑。 工具文件夹：存放一些工具函数和库文件，便于在小程序中调用。这些文件通常放在一个名为utils的文件夹中。
STM32H743+RTThread+LVGL
最新发布
08-04
.
面向对象重要培训资料分享12面向对象开发技术资料.zip
08-04
面向对象重要培训资料分享12面向对象开发技术资料.zip
2022年最新盲盒商城完整运营源码/对接免签支付接口
08-04
2022年最新盲盒商城完整运营源码/对接免签支付接口，源码花钱买来的 搭建环境 Linux7.6-Nginx 1.18.0 PHP-7.2（安装拓展fileinfo sg11 redis） MySQL 5.6.50 PHP7.2 删除所有禁用函数，之后重栽并重启PHP7.2 -------------------------------------------------------------------------- 1、上传源码至网站根目录，创建数据库并导入 2、网站运行目录选择/public，关闭防跨站 3、网站伪静态规则选择thinkphp 4、开始ssl，打开强制https（在宝塔一键配置就可以） 5、数据库修改地址：.env 文件 6、后台地址：域名/zgsht.php 账号密码：admin 123456 支付商户设置：菜单栏-平台设置 7、前台地址：域名/h5
跨界融合：YOLO与GAN的梦幻组合
08-04
"YOLO" 是 "You Only Look Once" 的缩写，它是一种流行的实时物体检测算法。YOLO 算法的特点是它将物体检测任务视为一个单一的回归问题，直接从图像像素到边界框坐标和类别概率的映射。这种算法的设计允许它在保持高精度的同时实现快速的检测速度，因此特别适合需要实时反馈的应用场景。 YOLO 算法有多个版本，比如 YOLOv1、YOLOv2（也称为 YOLO9000）、YOLOv3 和 YOLOv4 等，每个版本都在前一个版本的基础上进行了改进和优化，以提高检测速度和准确性。 "YOLO编程" 可能是指使用 YOLO 算法进行编程实践，比如实现物体检测模型，或者将其集成到应用程序中。如果你需要更详细的信息或者具体的编程指导，请告诉我你的具体需求。
c语言读者写者问题代码
06-01
引用:使用POSIX信号量机制解决读者-写者问题C语言实现，读者和写者进程数量可设置。[^1] ```c #include #include #include #include #include #include #include #define FILE_MODE (S_IRUSR | S_IWUSR | S...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值