Linux c编程之多线程

已于 2022-12-15 15:10:38 修改
阅读量1.5k 收藏 18
点赞数 2
分类专栏： Linux C网络编程实践 文章标签： linux 多线程 pthread_create c语言 pthread
于 2022-12-11 19:54:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szkbsgy/article/details/128242188
版权

一、说明

  运行的程序叫进程，进程是系统资源分配的最小单元。而线程是操作系统能够进行运算调度的最小单位。一个进程默认是有一个线程在运行，也叫单线程进程，也可以启动多个线程，叫做多线程进程。
多线程有如下特点：

  • 共用同一进程的地址空间
  • 共享进程的全局变量

二、常用API

2.1 pthread_create()

#include <pthread.h>
int pthread_create(pthread_t *thread,
                   const pthread_attr_t *attr,
                   void *(*start_routine) (void *),
                   void *arg);

作用：创建新线程
参数说明：
  thread: 线程ID，是输出参数，创建成功后，系统将thread设置为线程ID
  attr： 线程属性，使用pthread_attr_init和相关的函数进行初始化。如果该参数为NULL,则使用默认的属性创建线程
  start_routine: 新线程执行的函数
  arg: 新线程的函数参数
返回值：
  成功返回0，失败返回错误号

2.2 pthread_join()

int pthread_join(pthread_t thread, void **retval);

作用：阻塞等待指定的线程终止，回收相应的资源。如果线程已
  经终止，则pthread_join立即返回。
参数说明：
  thread: 线程ID
  retval： 输出参数，用来保存线程的退出状态（比如调
    用pthread_exit()指定的退出值）。如果
    不需要获取退出状态时，可以使用NULL
返回值：
  成功返回0，失败返回错误号

2.3 pthread_cancel()

int pthread_cancel(pthread_t thread);

作用：取消（结束）线程
参数说明：
  thread: 线程ID

2.4 pthread_exit()

void pthread_exit(void *retval);

作用：主动退出线程
参数说明：
  retval: 线程退出状态值。如果线程是非分离状态，则可以在另一个线程通过调用pthread_join获得退出的状态值

2.5 pthread_attr_init()

 int pthread_attr_init(pthread_attr_t *attr);

作用：初始化属性
返回值：成功返回0， 失败返回错误号

2.6 pthread_attr_destroy()

int pthread_attr_destroy(pthread_attr_t *attr);

作用：销毁属性
返回值：成功返回0， 失败返回错误号

2.7 pthread_attr_setdetachstate()

    int pthread_attr_setdetachstate(pthread_attr_t *attr,
            int detachstate);

作用：将线程设置为分离状态
参数说明：
  thread: 线程ID
返回值：成功返回0， 失败返回错误号

2.8 pthread_attr_getdetachstate()

    int pthread_attr_getdetachstate(pthread_attr_t *attr, 
        int *detachstate);

作用：获取分离状态信息
参数说明：
  attr: 属性
  detachstate：分离状态变量，传入参数。
        0：不分离 1：分离
返回值：成功返回0，失败返回错误号

2.9 pthread_t pthread_self()

 pthread_t pthread_self(void);

作用： 获取当前线程的ID
返回值：返回线程的ID

2.10 pthread_detach()

 int pthread_detach(pthread_t thread);

作用: 将线程设置为分离状态
参数说明：
  thread: 线程ID
返回值:成功返回0,失败返回错误号

2.11 pthread_cond_init()

    #include <pthread.h>
    int pthread_cond_init(pthread_cond_t *restrict cond,
              const pthread_condattr_t *restrict attr);

作用：初始化条件变量

2.12 pthread_cond_destroy()

    #include <pthread.h>
    int pthread_cond_destroy(pthread_cond_t *cond);

作用：销毁条件变量

2.13 互斥锁pthread_mutex_xxx()

    #include <pthread.h>
    int pthread_mutex_lock(pthread_mutex_t *mutex);
    int pthread_mutex_trylock(pthread_mutex_t *mutex);
    int pthread_mutex_unlock(pthread_mutex_t *mutex);

注：以上所有的pthread_xxx()函数编译时需要链接thread库（-pthread）

三、实例解析

3.1 最简单的线程

multi_pthread.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

void *thread_func(void *arg)
{
    pthread_t tid = 0;

    tid = pthread_self();
    printf("sub tid:%ld in sub thread\n", tid);

    while (1) {
        printf("I am sub pthread\n");
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    pthread_t main_tid = 0;
    pthread_attr_t attr;

    ret = pthread_create(&tid, NULL, thread_func, NULL);

    main_tid = pthread_self();
    printf("ret:%d, sub tid:%ld, main tid:%ld\n", ret, tid, main_tid);

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out multi_pthread.c -lpthread
clean:
	-@rm a.out

注：编译时需要链接pthread库
测试：

$ ./a.out 
ret:0, sub tid:140442318440192, main tid:140442326722368
I am main thread
sub tid:140442318440192 in sub thread
I am sub pthread
I am main thread
I am sub pthread
I am main thread
I am sub pthread
I am main thread
I am sub pthread

3.2 线程参数

3.2.1 变量参数

thread_param.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

void *thread_func(void *arg)
{
    pthread_t tid = 0;
    long thread_number = -1;

    thread_number = (long)arg;

    tid = pthread_self();
    printf("tid:%ld, number:%ld\n", tid, thread_number);

    while (1) {
        printf("I am sub pthread, thread number:%ld\n", thread_number);
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    long i = 0;
    pthread_t tid = 0;
    pthread_t main_tid = 0;

    for (i = 0; i < 3; i++) {
        ret = pthread_create(&tid, NULL, thread_func,  (void *)i);
    }

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread_param.c -lpthread
clean:
	-@rm a.out

测试：

$ ./a.out 
I am main thread
tid:139938984036096, number:2
I am sub pthread, thread number:2
tid:139938992428800, number:1
I am sub pthread, thread number:1
tid:139939000821504, number:0
I am sub pthread, thread number:0
I am main thread
I am sub pthread, thread number:2
I am sub pthread, thread number:1
I am sub pthread, thread number:0

3.2.2 结构体参数

thread.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

typedef struct thread_info_s
{
    int number;
    char name[32];
} thread_info_t;

thread_info_t g_thread_info;

void *thread_func(void *arg)
{
    pthread_t tid = 0;
    thread_info_t *thread_info = NULL;

    thread_info = (thread_info_t *)arg;

    tid = pthread_self();
    printf("tid:%ld, name:%s, number:%d\n",
                    tid, thread_info->name, thread_info->number);

    while (1) {
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    pthread_t main_tid = 0;

    g_thread_info.number = 1;
    strcpy(g_thread_info.name, "test-thread");

    ret = pthread_create(&tid, NULL, thread_func,  (void *)&g_thread_info);

    while (1) {
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果：

$ ./a.out 
tid:140212589033216, name:test-thread, number:1

3.3 线程的退出值及分离属性

3.3.1 退出值为字符串

#include <stdio.h>
#include <string.h>
#include <pthread.h>

void *thread_func(void *arg)
{
    pthread_t tid = 0;

    tid = pthread_self();
    printf("sub tid:%ld\n", tid);

    sleep(3);

    pthread_exit((void *)"hello world");
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    void *exit_value = NULL;

    ret = pthread_create(&tid, NULL, thread_func, NULL);

    pthread_join(tid, (void **)(&exit_value));
    printf("thread exit value:%s\n", (char *)exit_value);

    return 0;
}

测试：

$ ./a.out 
sub tid:140493947586304
thread exit value:hello world

3.3.2 退出值为整型

#include <stdio.h>
#include <string.h>
#include <pthread.h>

void *thread_func(void *arg)
{
    pthread_t tid = 0;
    static int exit_value = 5;

    tid = pthread_self();
    printf("sub tid:%ld\n", tid);

    sleep(3);

    pthread_exit((void *)&exit_value);
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    int *exit_value = NULL;

    ret = pthread_create(&tid, NULL, thread_func, NULL);

    pthread_join(tid, (void **)(&exit_value));
    printf("thread exit value:%d\n", *exit_value);

    return 0;
}

测试：

$ ./a.out 
sub tid:139728337950464
thread exit value:5

3.3.3 线程分离状态时

#include <stdio.h>
#include <string.h>
#include <pthread.h>

void *thread_func(void *arg)
{
    pthread_t tid = 0;

    tid = pthread_self();
    printf("sub tid:%ld\n", tid);

    sleep(10);

    pthread_exit((void *)"hello world");
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid = 0;
    void *exit_value = NULL;
    pthread_attr_t thread_attr;
    int detachstate = 1;

    pthread_attr_init(&thread_attr);

    pthread_attr_setdetachstate(&thread_attr, detachstate);

    ret = pthread_create(&tid, &thread_attr, thread_func, NULL);

    pthread_join(tid, (void **)(&exit_value));
    printf("thread exit value:%s\n", (char *)exit_value);

    pthread_attr_destroy(&thread_attr);

    while (1) {
        sleep(2);
    }

    return 0;
}

测试结果：

$ ./a.out 
thread exit value:(null)
sub tid:140123777509120

3.4 同步互斥锁

没加锁之前：
thread.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

#define THREAD_NUMBER 3

int g_seq = 0;

void *thread_func(void *arg)
{
    long thread_number = -1;

    thread_number = (long)arg;

    while (1) {
        g_seq++;
        printf("I am sub pthread, thread number:%ld, g_seq:%d\n", thread_number, g_seq);
        usleep(1000);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    long i = 0;
    pthread_t tid[THREAD_NUMBER];

    for (i = 0; i < THREAD_NUMBER; i++) {
        ret = pthread_create(&tid[i], NULL, thread_func,  (void *)i);
    }

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果:

I am sub pthread, thread number:0, g_seq:1669
I am sub pthread, thread number:2, g_seq:1670
I am sub pthread, thread number:1, g_seq:1671
I am sub pthread, thread number:0, g_seq:1671
I am sub pthread, thread number:2, g_seq:1672
I am sub pthread, thread number:0, g_seq:1673
I am sub pthread, thread number:1, g_seq:1673
I am sub pthread, thread number:2, g_seq:1674
I am sub pthread, thread number:0, g_seq:1675
I am sub pthread, thread number:1, g_seq:1675
I am sub pthread, thread number:2, g_seq:1676
I am sub pthread, thread number:0, g_seq:1677
I am sub pthread, thread number:1, g_seq:1677
I am sub pthread, thread number:2, g_seq:1678
I am sub pthread, thread number:1, g_seq:1679
I am sub pthread, thread number:0, g_seq:1679
I am sub pthread, thread number:2, g_seq:1680

增加锁后：
thread.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

#define THREAD_NUMBER 3

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int g_seq = 0;

void *thread_func(void *arg)
{
    long thread_number = -1;

    thread_number = (long)arg;

    while (1) {
        pthread_mutex_lock(&mutex);
        g_seq++;
        printf("I am sub pthread, thread number:%ld, g_seq:%d\n", thread_number, g_seq);
        pthread_mutex_unlock(&mutex);
        usleep(1000);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    long i = 0;
    pthread_t tid[THREAD_NUMBER];

    for (i = 0; i < THREAD_NUMBER; i++) {
        ret = pthread_create(&tid[i], NULL, thread_func,  (void *)i);
    }

    while (1) {
        printf("I am main thread\n");
        sleep(1);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果：

I am sub pthread, thread number:1, g_seq:814
I am sub pthread, thread number:0, g_seq:815
I am sub pthread, thread number:2, g_seq:816
I am sub pthread, thread number:2, g_seq:817
I am sub pthread, thread number:0, g_seq:818
I am sub pthread, thread number:1, g_seq:819
I am sub pthread, thread number:0, g_seq:820
I am sub pthread, thread number:2, g_seq:821
I am sub pthread, thread number:1, g_seq:822
I am sub pthread, thread number:0, g_seq:823
I am sub pthread, thread number:2, g_seq:824
I am sub pthread, thread number:1, g_seq:825

3.5 同步条件变量

thread.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

#define THREAD_NUMBER 3

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int g_flag = 0;

void *producer_func(void *arg)
{
    while (1) {
        pthread_mutex_lock(&mutex);
        printf("%s: get lock, flag is:%d\n", __FUNCTION__, g_flag);
        if (1 == g_flag) {
            printf("%s: flag is 0, wait...\n", __FUNCTION__);
            pthread_cond_wait(&cond, &mutex);
            printf("%s: after wait, flag:%d\n", __FUNCTION__, g_flag);
        }
        printf("%s: sleep 10 seconds\n", __FUNCTION__);  
        sleep(10);
        g_flag = 1;
        printf("%s: sleep finish, flag:%d\n", __FUNCTION__, g_flag);
        printf("%s: send cond signal\n", __FUNCTION__);  
        pthread_cond_signal(&cond);
        printf("%s: release lock\n", __FUNCTION__);  
        pthread_mutex_unlock(&mutex);
    }
}

void *customer_func(void *arg)
{
    while (1) {
        pthread_mutex_lock(&mutex);
        printf("%s: get lock, flag is:%d\n", __FUNCTION__, g_flag);
        if (0 == g_flag) {
            printf("%s: flag is 0, wait...\n", __FUNCTION__);
            pthread_cond_wait(&cond, &mutex);
            printf("%s: after wait, flag:%d\n", __FUNCTION__, g_flag);
        }
        printf("%s: sleep 10 seconds\n", __FUNCTION__);  
        sleep(10);
        g_flag = 0;
        printf("%s: sleep finish, flag:%d\n", __FUNCTION__, g_flag);
        printf("%s: send cond signal\n", __FUNCTION__);  
        pthread_cond_signal(&cond);
        printf("%s: release lock\n", __FUNCTION__);  
        pthread_mutex_unlock(&mutex);
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t producer_tid;
    pthread_t customer_tid;

    ret = pthread_create(&producer_tid, NULL, producer_func, NULL);
    ret = pthread_create(&customer_tid, NULL, customer_func, NULL);

    while (1) {
        sleep(10);
    }

    return 0;
}

Makefile:

all:
	gcc -o a.out thread.c -lpthread
clean:
	-@rm a.out

测试结果:

customer_func: get lock, flag is:0
customer_func: flag is 0, wait...
producer_func: get lock, flag is:0
producer_func: sleep 10 seconds
producer_func: sleep finish, flag:1
producer_func: send cond signal
producer_func: release lock
producer_func: get lock, flag is:1
producer_func: flag is 0, wait...
customer_func: after wait, flag:1
customer_func: sleep 10 seconds
customer_func: sleep finish, flag:0
customer_func: send cond signal
customer_func: release lock
customer_func: get lock, flag is:0
customer_func: flag is 0, wait...
producer_func: after wait, flag:0
producer_func: sleep 10 seconds
浪游东戴河
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux下c语言多线程编程
m0_47170940的博客
03-30 1万+
创建线程函数pthread_create()和等待线程函数pthread_join()的用法。 注意：在创建线程pthread_create()之前，要先定义线程标识符： pthread_t 自定义线程名； 例子1：创建线程以及等待线程执行完毕。 #include <stdio.h> #include <stdlib.h> #include <pthread.h> //线程要运行的函数，除了函数名myfunc，其他全都是固定的。 void* myfunc() { p
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
linux下C语言多线程编程总结
ftzchina的博客
11-29 1403
一：线程的创建与等待 线程创建函数： Create a new thread, starting with execution of START-ROUTINE getting passed ARG. Creation attributed come from ATTR. The new handle is stored in *NEWTHREAD. extern int pthread_create (pthread_t *__restrict __newthread,
Linux C语言 21-多线程
Tianwx的博客
11-23 1500
本节关键字：Linux、C语言、线程，pthread库的使用，POSIX 相关C库函数：pthread_create、pthread_exit、pthread_cancel、pthread_join ...
Linux多线程编程
C_Trip的博客
11-19 3138
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
Linux C 编程——多线程
null的专栏
03-13 2597
线程是计算机中独立运行的最小单位，运行时占用很少的系统资源。与多进程相比，多进程具有多进程不具备的一些优点，其最重要的是：对于多线程来说，其能够比多进程更加节省资源。1、线程创建在Linux中，新建的线程并不是在原先的进程中，而是系统通过一个系统调用clone()。该系统copy了一个和原先进程完全一样的进程，并在这个进程中执行线程函数。在Linux中，通过函数pthread_create()函数实
c语言系统编程十二：Linux多任务编程之线程
qq_33808440的博客
09-06 759
线程是轻量级的进程（LWP）；在Linux环境下线程的本质仍然是进程；为了让进程完成一定的工作，进程必须至少包含一个线程；进程是系统分配资源的基本单位；线程是cpu执行调度的基本单位；线程依赖于进程，线程共享进程的资源，线程独立的资源有（计数器，一组寄存器，栈）；进程结束，当前进程的所有线程都将立刻结束。
【嵌入式】Linux C编程——多线程编程总结
a_qwq_a的博客
06-04 734
对多线程编程的总结笔记
linux网络编程之多进程、多线程
02-07 726
这里写目录标题多进程模型demo多线程模型demo 先read 函数的返回值 非常重要 > 0 实际读到的字节数 = 0 已经读到结尾（对端已经关闭） -1 应进一步判断errno的值：重要!!! -1一定要进行判断，否则接收端一直在接收 errno = EAGAIN or EWOULDBLOCK 设置了非阻塞方式读,没有数据到达。 errno = EINTR 慢速系统调用被 中断。 errno = “其他情况” 异常。 多进程模型 socket() bind() listen(
linux下c语言的多线程编程
08-29
Linux下C语言的多线程编程 在 Linux 系统中，C 语言的多线程编程是非常重要的一部分。多线程编程可以提高程序的性能，使得程序能够更好地利用系统资源。在本文中，我们将详细介绍 Linux 下 C 语言的多线程编程。 ...
Linux系统下的多线程编程入门.pdf
07-14
在Linux系统中，多线程编程是开发高效并发应用程序的关键技术。线程是操作系统调度的基本单位，它允许在一个进程中执行多个并发线程，共享资源，从而提高程序的响应速度和系统资源利用率。与进程相比，线程具有启动...
linux c多线程编程实例代码
09-04
在Linux系统中，C语言进行多线程编程可以利用POSIX线程库（pthread），它提供了丰富的线程操作接口。本实例代码展示了如何创建、同步和管理多线程。以下是详细的知识点解析： 1. **多线程概念**：多线程是指一个...
Linux下的多线程编程.pdf
09-06
Linux系统提供了 LinuxThreads 库，它是一个符合 POSIX IO03．1c 标准的内核级多线程函数库。在 LinuxThreads 库中提供了一些多线程编程的关键函数，如 pthread_create() 函数，它可以创建一个新的线程，并执行指定...
Windows 下的sqlserver数据拷贝到linux
cyw8998的专栏
07-25 279
2.在 >1 提示符下，输入以下 RESTORE DATABASE 命令，并在每行后按 Enter（无法同时复制和粘贴整个多行命令）。将出现的所有 gpdb 替换为数据库的名称。1.启动 sqlcmd。下面的示例以 SA 用户身份连接到本地 SQL Server。出现提示时输入密码，或使用 -P 参数指定密码。SSH打开linux终端。
Linux：进程信号（二.信号的保存与处理、递达、volatile关键字、SIGCHLD信号）
qq_74415153的博客
07-25 1192
1.信号保存 1.1递达、未决、阻塞等概念 1.2再次理解信号产生与保存 1.3信号集操作函数 sigset_t类型 sigprocmask系统调用 sigpending系统调用 2.信号的处理/递达 2.1信号处理时机与过程 2.2用户态和内核态 2.3再看进程地址空间 谁来运行OS 2.4信号的捕捉-sigaction()函数 3.补充知识 3.1可重入函数 3.2volatile关键字 3.3 SIGCHLD信号
【Linux】通过分配虚拟内存的方式来解决因内存不够而导致部署的项目自动挂掉
smile_sundays的博客
07-24 782
（6）这样配置，每次服务器重启，就没了，所以设置开机自动挂载 Swap 分区，编辑文件 /etc/fstab，在下面加入：/var/swap　　swap　　swap　　default　　0 0。第一种方法：进行JVM调优可以改善这种情况，但是项目太多，我们的个人服务器配置实在太低，仍然无法解决此问题，这里不做讨论了。（5）启动完项目后，执行： ps aux | grep java 查看所有服务，看看是否还会再挂，一般就不会了。（2）划分虚拟内存分区（大小为2G），执行命令会卡一小会无响应。
Linux初学基本命令
最新发布
yuan20010401的博客
07-25 623
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
60个常见的 Linux 指令
yatingliu的博客
07-25 1367
是 “substitute user” 或 “switch user” 的缩写，它可以让你切换到另一个用户账户，包括 root 用户。是 “manual” 的缩写，通过它你可以访问系统的手册页（manual pages），这些手册页提供了详细的使用说明和参考信息。在一些 Linux 发行版中，adduser 是 useradd 的一个友好封装，功能上类似但提供了更多的默认设置和提示。-f, --force：强制删除，不提示错误信息，即使文件不存在也不会报错。：设置密码过期时间，单位为天。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浪游东戴河

你就是这个世界的唯一

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

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

打赏作者

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

抵扣说明：

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

余额充值