IO进程线程day7（2023.8.4）

一、Xmind整理：

二、课上练习：

练习1：创建两个线程：其中一个线程拷贝前半部分，另一个线程拷贝后半部分。

            只允许开一份资源，且用互斥锁方式实现。 提示：找临界区--->找临界资源。

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <head.h>
#include <pthread.h>//定义一个结构体，传入到线程中
struct Msg
{int fd_r;int fd_w;off_t size;
};//定义互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//拷贝前半部分
void* callBack1(void* arg)      //void* arg = &fileinfo
{int fd_r = ((struct Msg*)arg)->fd_r;int fd_w = ((struct Msg*)arg)->fd_w;off_t size = ((struct Msg*)arg)->size;//修改文件偏移量到文件开头位置off_t offset = 0;char c = 0;for(int i = 0; i<size/2; i++){/*********临界区****************/pthread_mutex_lock(&mutex);     //上锁lseek(fd_r, offset, SEEK_SET);lseek(fd_w, offset, SEEK_SET);read(fd_r, &c, 1);write(fd_w, &c, 1);offset = lseek(fd_r, 0, SEEK_CUR);pthread_mutex_unlock(&mutex);   //解锁/*********临界区****************/}printf("前半部分拷贝完毕\n");pthread_exit(NULL);
}//拷贝后半部分
void* callBack2(void* arg)      //void* arg = &fileinfo
{int fd_r = ((struct Msg*)arg)->fd_r;int fd_w = ((struct Msg*)arg)->fd_w;off_t size = ((struct Msg*)arg)->size;//修改文件偏移量到sizee/2位置off_t offset = size/2;char c = 0;for(int i = size/2; i<size; i++){/*********临界区****************/pthread_mutex_lock(&mutex);     //上锁lseek(fd_r, offset, SEEK_SET);lseek(fd_w, offset, SEEK_SET);read(fd_r, &c, 1);write(fd_w, &c, 1);offset = lseek(fd_r, 0, SEEK_CUR);pthread_mutex_unlock(&mutex);   //解锁/*********临界区****************/}printf("后半部分拷贝完毕\n");pthread_exit(NULL);
}int main(int argc, const char *argv[])
{//以读的方式打开源文件int fd_r = open("./1.png", O_RDONLY);if(fd_r < 0){ERR_MSG("open");return -1;}//以写的方式打开目标文件int fd_w = open("./copy.png", O_WRONLY|O_CREAT|O_TRUNC, 0664);if(fd_w < 0){ERR_MSG("open");return -1;}off_t size = lseek(fd_r, 0, SEEK_END);struct Msg fileinfo;fileinfo.fd_r = fd_r;fileinfo.fd_w = fd_w;fileinfo.size = size;//创建一个线程pthread_t tid1, tid2;if(pthread_create(&tid1, NULL, callBack1, &fileinfo) != 0){fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);return -1;}                                                                       if(pthread_create(&tid2, NULL, callBack2, &fileinfo) != 0){fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);return -1;}//阻塞等待分支线程退出pthread_join(tid2, NULL);pthread_join(tid1, NULL);//销毁互斥锁pthread_mutex_destroy(&mutex);//关闭文件close(fd_r);close(fd_w);return 0;
}

练习2：sem_init

功能：创建并初始化信号量

原型:

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);

参数：

sem_t *sem：存储申请后的信号量;
int pshared：共享标识
0：信号量用于同一个进程下的线程的同步互斥；
非0：用于进程间的同步互斥机制;
unsigned int value：信号量的初始值;

返回值：

成功，返回0；
失败，返回-1，更新errno;

练习3：sem_wait（P操作）

功能：申请信号量，若申请成功，信号量的值-1

当信号量的值大于0，则申请信号量成功，信号量的值-1；

当信号量的值等于0，则申请信号量操作会阻塞，线程进入休眠等待信号量的值大于0，解除阻塞。

原型:

#include <semaphore.h>
int sem_wait(sem_t *sem);

参数：

sem_t *sem：指定要操作哪个信号灯;

返回值：

成功，返回0;
失败，返回-1，更新errno;

练习4：sem_post（V操作）

功能：释放信号灯的值

原型:

#include <semaphore.h>
int sem_post(sem_t *sem);

返回值：

 成功，返回0;失败，返回-1，更新errno;

练习5：sem_destroy

原型:

#include <semaphore.h>
int sem_destroy(sem_t *sem);

小练：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
#include <semaphore.h>
void* CallBack(void* arg)   //void* arg = &sem;
{sleep(3);//V操作if(sem_post((sem_t*)arg)<0){perror("sem_post");return NULL;}printf("V operation success __%d__\n",__LINE__);pthread_exit(NULL);
}int main(int argc, const char *argv[])                                     
{sem_t sem;if(sem_init(&sem,0,2)<0){perror("sem_init");return -1;}printf("sem_init success __%d__\n",__LINE__);//创建一个线程，3s后V一次pthread_t tid;if(pthread_create(&tid,NULL,CallBack,(void*)&sem) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}//P操作 if(sem_wait(&sem)<0){perror("sem_wait");return -1;}printf("P operation success __%d__\n",__LINE__);//P操作if(sem_wait(&sem)<0){perror("sem_wait");return -1;}printf("P operation success __%d__\n",__LINE__);//P操作if(sem_wait(&sem)<0){perror("sem_wait");return -1;}printf("P operation success __%d__\n",__LINE__);pthread_join(tid,NULL);sem_destroy(&sem);return 0;
}

练习6：先打印1234567，后打印7654321

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
#include <semaphore.h>
//临界资源
char buf[]="1234567";void* CallBack1(void* arg)
{while(1){/**********临界区*********///p操作if(sem_wait((sem_t*)arg)<0){perror("sem_wait");return NULL;}printf("%s\n",buf);//v操作if(sem_post((sem_t*)arg)<0){perror("sem_post");return NULL;}/**********临界区*********/}pthread_exit(NULL);
}
void* CallBack2(void* arg)
{char tmp=0;while(1){/**********临界区*********///p操作if(sem_wait((sem_t*)arg)<0){perror("sem_wait");return NULL;}for(int i=0;i<strlen(buf)/2;i++){tmp=buf[i];buf[i]=buf[strlen(buf)-1-i];buf[strlen(buf)-1-i]=tmp;}//v操作if(sem_post((sem_t*)arg)<0){perror("sem_post");return NULL;}/**********临界区*********/}pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{sem_t sem;if(sem_init(&sem,0,1)<0){perror("sem_init");return -1;}printf("sem_init success   __%d__\n",__LINE__);//创建线程pthread_t tid1,tid2;if(pthread_create(&tid1,NULL,CallBack1,(void*)&sem) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_detach(tid1);  //分离线程1if(pthread_create(&tid2,NULL,CallBack2,(void*)&sem) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_join(tid2,NULL);        //阻塞等待线程2退出//销毁信号量sem_destroy(&sem);return 0;
}

练习7：pthread_cond_init

功能：创建并初始化一个条件变量（唤醒条件）

原型：

#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);

参数：

pthread_cond_t *cond：指定存储创建并初始化后的条件变量;
pthread_condattr_t *cond_attr：条件变量属性，设置条件变量适用于进程间还是线程间的同步互斥。填NULL，默认属性，用于线程

返回值：

成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。

练习8：pthread_cond_wait

功能：阻塞函数，让当前线程进入休眠阶段，并设置一个条件变量，等待被唤醒

原型：

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

参数：

pthread_cond_t *cond：指定条件变量; 我们一般称 该线程睡在该条件变量上;
pthread_mutex_t *mutex：指定要解开的互斥锁；

返回值：

成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。

函数步骤： 

1.解开互斥锁，同时让当前线程进入休眠阶段等待被唤醒。（原子操作：原子从操作是指不会被调度机制打断的操作）

2.等待被指定条件变量唤醒

3.当其他线程pthread_cond_signal的时候，线程会从cond_wait队列移动到mutex_lock队列中，且signal计数器+1，线程尝试上锁

4.若上锁成功，则线程完全被唤醒，此时线程会从当前位置继续往后执行，且signal计数器-1;

5.若上锁失败，则线程会重新回到cond_wait队列上继续休眠，等待下一次唤醒。

ps：如果上述不能理解，则简化版：pthread_cond_signal肯定会随机唤醒一个睡在cond上的线程。

练习9：pthread_conde_signal

功能：通过指定条件变量，唤醒睡在该条件变量上的某个线程

原型：

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

参数：

pthread_cond_t *cond：唤醒睡在哪个条件变量上的线程;

返回值：

成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。

练习10：pthread_cond_destroy

功能：销毁条件变量

原型：

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

小练1：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
#include <semaphore.h>
//临界资源
char buf[]="1234567";
//互斥锁          方式2
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;                                               
//条件变量创建　　方式2
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int flag = 0;  //限制访问时机
void* CallBack1(void* arg)
{while(1){/**********临界区*********///上锁pthread_mutex_lock(&mutex);if(flag !=0){//让线程进入休眠等待阶段，同时解开互斥锁//设置一个唤醒条件pthread_cond_wait(&cond,&mutex);//当被唤醒的时候，会立即尝试上锁//上锁成功，则唤醒成功，则从当前位置继续往后执行//上锁失败，则重新回到cond上继续休眠，等待下一次唤醒}printf("%s\n",buf);flag = 1;//唤醒睡在cond上的线程pthread_cond_signal(&cond);//目前大家暂时理解为：只要唤醒成功了，对方线程肯定能上锁成功//解锁pthread_mutex_unlock(&mutex);/**********临界区*********/}pthread_exit(NULL);
}
void* CallBack2(void* arg)
{char* start,*end;char tmp=0;while(1){/**********临界区*********///上锁pthread_mutex_lock(&mutex);if(flag !=1){//让线程进入休眠等待阶段，同时解开互斥锁//设置一个唤醒条件pthread_cond_wait(&cond,&mutex);//当被唤醒的时候，会立即尝试上锁//上锁成功，则唤醒成功，则从当前位置继续往后执行//上锁失败，则重新回到cond上继续休眠，等待下一次唤醒}start = buf;end = buf+strlen(buf)-1;while(start < end){tmp = *start;*start = *end;*end = tmp;start++;end--;}flag = 0;//唤醒睡在cond上的线程pthread_cond_signal(&cond);//目前大家暂时理解为：只要唤醒成功了，对方线程肯定能上锁成功//解锁pthread_mutex_unlock(&mutex);/**********临界区*********/}pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{/*//创建一个条件变量　方式1if(pthread_cond_init(&cond,NULL)!= 0){fprintf(stderr,"pthread_cond_init failed __%d__\n",__LINE__);return -1;}*///创建线程pthread_t tid1,tid2;if(pthread_create(&tid1,NULL,CallBack1,NULL) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_detach(tid1);  //分离线程1if(pthread_create(&tid2,NULL,CallBack2,NULL) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_join(tid2,NULL);        //阻塞等待线程2退出//销毁互斥锁pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);return 0;
}

小练2：创建三个线程 id号为ABC，要求三个线程循环打印自己的ID号，运行顺序为 ABCABC......

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
#include <semaphore.h>//互斥锁          方式2
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//条件变量创建　　方式2
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;int flag = 1;   //1:A  2:B  3:Cvoid* A(void* arg)
{while(1){//上锁pthread_mutex_lock(&mutex);if(flag != 1){pthread_cond_wait(&cond1,&mutex);                                                        }printf("A");flag = 2 ;pthread_cond_signal(&cond2);//解锁　pthread_mutex_unlock(&mutex);}pthread_exit(NULL);
}
void* B(void* arg)
{while(1){//上锁pthread_mutex_lock(&mutex);if(flag != 2){pthread_cond_wait(&cond2,&mutex);}printf("B");flag = 3 ;pthread_cond_signal(&cond3);//解锁　pthread_mutex_unlock(&mutex);}pthread_exit(NULL);
}
void* C(void* arg)
{while(1){//上锁pthread_mutex_lock(&mutex);if(flag != 3){pthread_cond_wait(&cond3,&mutex);}printf("C\n");flag = 1 ;pthread_cond_signal(&cond1);//解锁　pthread_mutex_unlock(&mutex);}pthread_exit(NULL);
}int main(int argc, const char *argv[])
{/*//创建一个条件变量　方式1if(pthread_cond_init(&cond,NULL)!= 0){fprintf(stderr,"pthread_cond_init failed __%d__\n",__LINE__);return -1;}*///创建线程pthread_t tid1,tid2,tid3;if(pthread_create(&tid1,NULL,A,NULL) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_detach(tid1);  //分离线程1if(pthread_create(&tid2,NULL,B,NULL) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_detach(tid2);if(pthread_create(&tid3,NULL,C,NULL) != 0){fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);return -1;}pthread_join(tid3,NULL);        //阻塞等待线程2退出//销毁互斥锁pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond1);pthread_cond_destroy(&cond2);pthread_cond_destroy(&cond3);return 0;
}

三、课后作业：

1.使用信号量的方式实现，将倒置以及打印的那道题目，在第一题的基础上加上一个需求：要求打印，倒置线程，顺序执行。出现的现象为先打印1234567，后打印7654321（不使用flag）

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>//临界资源
char buf[] = "1234567";//信号量
sem_t sem1;
sem_t sem2;void* callBack1(void* arg)
{while(1){sem_wait(&sem1);fprintf(stderr,"%s\n",buf);sem_post(&sem2);}                                                                          
}
void* callBack2(void* arg)
{char tmp = 0;while(1){sem_wait(&sem2);for(int i=0; i<strlen(buf)/2; i++){tmp = buf[i];buf[i] = buf[strlen(buf)-1-i];buf[strlen(buf)-1-i] = tmp;}sem_post(&sem1);}
}int main(int argc, const char *argv[])
{//申请信号量if(sem_init(&sem1, 0, 1) < 0){perror("sem_init");return -1;}if(sem_init(&sem2,0,0) < 0){perror("sem_init");return -1;}pthread_t tid1, tid2;if(pthread_create(&tid1, NULL, callBack1, NULL) != 0){fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);return -1;}pthread_detach(tid1);   //分离线程1if(pthread_create(&tid2, NULL, callBack2, NULL) != 0){fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);return -1;}pthread_join(tid2, NULL);   //阻塞等待线程2退出//销毁信号量sem_destroy(&sem1);sem_destroy(&sem2);return 0;
}

2.创建两个线程，其中一个线程读取文件中的数据，另外一个线程将读取到的内容打印到终端上，类似实现cat一个文件。

cat数据完毕后，要结束两个线程。

提示：先读数据，读到数据后将数据打印到终端上。

#include <stdio.h>
#include <head.h>
#include <pthread.h>
#include <semaphore.h>int fd;
char c;
sem_t sem1;
sem_t sem2;
int res = -1;void *callBack1(void *arg)
{while(1){sem_wait(&sem1);if(read(fd,&c,1) == 0){res = close(fd);sem_post(&sem2);break;}sem_post(&sem2);}                                                                        printf("线程1\n");pthread_exit(NULL);
}
void *callBack2(void *arg)
{while(1){sem_wait(&sem2);if(res == 0)break;write(1,&c,1);sem_post(&sem1);}printf("线程2\n");pthread_exit(NULL);
}int main(int argc, const char *argv[])
{fd = open("1.txt",O_RDONLY);if(fd < 0){perror("open");return -1;}if(sem_init(&sem1,0,1) < 0){perror("sem_init");return -1;}if(sem_init(&sem2,0,0) < 0){perror("sem_init");return -1;}pthread_t tid1,tid2;if(pthread_create(&tid1,NULL,callBack1,NULL) < 0){fprintf(stderr,"pthread_create falied __%d__",__LINE__);return -1;}if(pthread_create(&tid2,NULL,callBack2,NULL) < 0){fprintf(stderr,"pthread_create falied __%d__",__LINE__);return -1;}pthread_join(tid1,NULL);pthread_join(tid2,NULL);//销毁信号量sem_destroy(&sem1);sem_destroy(&sem2);return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/52755.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

面试热题（最长回文子串）

面试热题（最长回文子串）

给你一个字符串 s&#xff0c;找到 s 中最长的回文子串。 如果字符串的反序与原始字符串相同&#xff0c;则该字符串称为回文字符串 输入&#xff1a;s "babad" 输出&#xff1a;"bab" 最长回文子串以前的博客已经讲过KMP算法以及比较不常见的Manacher算法…
阅读更多...
Gartner发布《2023年全球RPA魔力象限》：90%RPA厂商，将提供生成式AI自动化

Gartner发布《2023年全球RPA魔力象限》：90%RPA厂商，将提供生成式AI自动化

8月3日&#xff0c;全球著名咨询调查机构Gartner发布了《2023年全球RPA魔力象限》&#xff0c;通过产品能力、技术创新、市场影响力等维度&#xff0c;对全球16家卓越RPA厂商进行了深度评估。 弘玑Cyclone&#xff08;Cyclone Robotics&#xff09;、来也&#xff08;Laiye&am…
阅读更多...
教资学习笔记总结

教资学习笔记总结

科目一 科目二 第一章 教育基础知识和基本原理 第一节 教育的认识 1.教育的概念 教育的词源&#xff1a;教育一词最早出现于《孟子尽心上》&#xff1a;“得天下英才而教育之”许慎在《说文解字》中最早解释教育&#xff1a;“教&#xff0c;上所施&#xff0c;下所效也”…
阅读更多...
opencv35-形态学操作-腐蚀cv2.erode()

opencv35-形态学操作-腐蚀cv2.erode()

形态学&#xff0c;即数学形态学&#xff08;Mathematical Morphology&#xff09;&#xff0c;是图像处理过程中一个非常重要的研 究方向。形态学主要从图像内提取分量信息&#xff0c;该分量信息通常对于表达和描绘图像的形状具有 重要意义&#xff0c;通常是图像理解时所使用…
阅读更多...
Docker实战-操作Docker容器实战(二)

Docker实战-操作Docker容器实战(二)

导语   上篇分享中，我们介绍了关于如何创建容器、如何启动容器、如何停止容器。这篇我们来分享一下如何操作容器。 如何进入容器 可以通过使用-d参数启动容器后会进入后台运行，用户无法查看容器中的信息，无法对容器中的信息进行操作。 这个时候如果我们需要进入容器对容器…
阅读更多...
聊聊比亚迪的DM-i技术

聊聊比亚迪的DM-i技术

比亚迪的DM-i技术是一种混合动力技术&#xff0c;结合了燃油发动机和电动技术&#xff0c;旨在提高汽车的燃油经济性和环境友好性。 DM-i技术的核心是搭载了一台高效的燃油发动机和一组电动机&#xff0c;通过电子控制系统实现两者的协同工作。在日常行驶中&#xff0c;汽车首先…
阅读更多...
SpringBoot项目-个人博客系统的实现【下】

SpringBoot项目-个人博客系统的实现【下】

10.实现强制要求登陆 当用户访问 博客列表页和 博客详情页时, 如果用户当前尚未登陆, 就自动跳转到登陆页面 1.添加拦截器 public class LoginInterceptor implements HandlerInterceptor {Overridepublic boolean preHandle(HttpServletRequest request, HttpServletRespon…
阅读更多...
kubernetes基于helm部署gitlab-runner

kubernetes基于helm部署gitlab-runner

kubernetes基于helm部署gitlab-runner 这篇博文介绍如何在 Kubernetes 中使用helm部署 GitLab-runner。 先决条件&#xff1a; 已运行的 Kubernetes 集群已运行的 gitlab 实例 项目地址&#xff1a;https://gitlab.com/gitlab-org/charts/gitlab-runner 官方文档&#xff…
阅读更多...
深度学习——注意力机制、自注意力机制

深度学习——注意力机制、自注意力机制

什么是注意力机制&#xff1f; 1.注意力机制的概念&#xff1a; 我们在听到一句话的时候&#xff0c;会不自觉的捕获关键信息&#xff0c;这种能力叫做注意力。 比如&#xff1a;“我吃了100个包子” 有的人会注意“我”&#xff0c;有的人会注意“100个”。 那么对于机器来说…
阅读更多...
【LeetCode-简单】剑指 Offer 52. 两个链表的第一个公共节点

【LeetCode-简单】剑指 Offer 52. 两个链表的第一个公共节点

题目 输入两个链表&#xff0c;找出它们的第一个公共节点。 如下面的两个链表&#xff1a; 在节点 c1 开始相交。 输入&#xff1a;intersectVal 8, listA [4,1,8,4,5], listB [5,0,1,8,4,5], skipA 2, skipB 3 输出&#xff1a;Reference of the node with value 8 输…
阅读更多...
Android优化篇|网络预连接

Android优化篇|网络预连接

作者&#xff1a;苍耳叔叔 一个示例 前后分别去请求同一个域名下的接口&#xff0c;通过 Charles 抓包&#xff0c;可以看到 Timing 下面的时间&#xff1a; 第二次请求时&#xff0c;DNS、Connect 和 TLS Handshake 部分都是 -&#xff0c;说明没有这部分的耗时&#xff0c;…
阅读更多...
大麦订单生成器 大麦一键生成订单

大麦订单生成器 大麦一键生成订单

后台一键生成链接&#xff0c;独立后台管理 教程&#xff1a;修改数据库config/Conn.php 不会可以看源码里有教程 下载源码程序&#xff1a;https://pan.baidu.com/s/16lN3gvRIZm7pqhvVMYYecQ?pwd6zw3
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023