1> 将互斥机制的代码实现重新敲一遍
代码:
#include<myhead.h>
int num=520;//临界资源
//1.创建互斥锁
pthread_mutex_t fastmutex;
//定义任务函数
void *task1(void *arg){
printf("1111111\n");
//3.临界区上面获取锁资源(上锁)
pthread_mutex_lock(&fastmutex);
num=1314;
sleep(3);
printf("task1:num = %d\n",num); //1314
//4. 释放锁资源
pthread_mutex_unlock(&fastmutex);
}
void *task2(void *arg){
printf("2222222\n");
pthread_mutex_lock(&fastmutex);
num++; //521
sleep(1); //休眠时任务1执行到赋值语句
printf("task2:num = %d\n",num);
pthread_mutex_unlock(&fastmutex);
}
int main(int argc, char const *argv[])
{
//2.初始化互斥锁
pthread_mutex_init(&fastmutex,NULL);
//线程创建
pthread_t tid1,tid2;
if(pthread_create(&tid1,NULL,task1,NULL)!=0){
printf("tid1 create error\n");
return 0;
}
if(pthread_create(&tid2,NULL,task2,NULL)!=0){
printf("tid2 create error\n");
return 0;
}
printf("tid1:%#lx, tid2:%#lx\n",tid1,tid2);
//回收资源
if(pthread_join(tid1,NULL)==0)
printf("tid1回收成功\n");
if(pthread_join(tid2,NULL)==0)
printf("tid2回收成功\n");
//5. 销毁锁资源
pthread_mutex_destroy(&fastmutex);
return 0;
}
结果:
2> 将无名信号量的代码实现重新敲一遍
代码:
#include<myhead.h>
//创建无名信号了
sem_t sem;
//定义生产者线程
void *task1(void *arg){
printf("1111111\n");
int num= 5;
while(num--){
//3.申请资源
// sem_wait(&sem);
sleep(1);
printf("我生产了一辆车\n");
//4.释放资源
sem_post(&sem);
}
pthread_exit(NULL);
}
//定义消费者线程
void *task2(void *arg){
printf("2222222\n");
int num= 5;
while(num--){
//3.申请资源
sem_wait(&sem);
printf("我消费了一辆车\n");
//4.释放资源
// sem_post(&sem);
}
pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
//初始化无名信号量
sem_init(&sem,0,0);
//第一个0:表示用于线程的同步
//第二个0:表示初始资源为0
//创建两个线程,分别是生产者和消费者
pthread_t tid1,tid2;
if(pthread_create(&tid1,NULL,task1,NULL)!=0){
printf("tid1 create error\n");
return 0;
}
if(pthread_create(&tid2,NULL,task2,NULL)!=0){
printf("tid2 create error\n");
return 0;
}
printf("tid1:%#lx, tid2:%#lx\n",tid1,tid2);
//回收资源
if(pthread_join(tid1,NULL)==0)
printf("tid1回收成功\n");
if(pthread_join(tid2,NULL)==0)
printf("tid2回收成功\n");
//释放无名信号量
sem_destroy(&sem);
return 0;
}
结果:
3> 将条件变量的代码实现重新敲一遍
代码:
#include<myhead.h>
//1. 定义条件变量
pthread_cond_t cond;
//11. 创建互斥锁
pthread_mutex_t fastmutex;
//定义生产者线程
void *task1(void *arg){
int num= 5;
while(num--){
sleep(1);
printf("%#lx:生产了一辆车\n",pthread_self());
//3. 唤醒一个消费者
pthread_cond_signal(&cond);
}
pthread_exit(NULL);
}
//定义消费者线程
void *task2(void *arg){
//33.临界区上面获取锁资源(上锁)
pthread_mutex_lock(&fastmutex);
//4. 进入等待队列
pthread_cond_wait(&cond,&fastmutex);
printf("%#lx:消费了一辆车\n",pthread_self());
//54. 释放锁资源
pthread_mutex_unlock(&fastmutex);
pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
//2. 初始化无名信号量
pthread_cond_init(&cond,NULL);
//22. 初始化互斥锁
pthread_mutex_init(&fastmutex,NULL);
//创建2个线程,分别是生产者和消费者
pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
if(pthread_create(&tid1,NULL,task1,NULL)!=0){
printf("tid1 create error\n");
return 0;
}
if(pthread_create(&tid2,NULL,task2,NULL)!=0){
printf("tid2 create error\n");
return 0;
}
if(pthread_create(&tid3,NULL,task2,NULL)!=0){
printf("tid3 create error\n");
return 0;
}
if(pthread_create(&tid4,NULL,task2,NULL)!=0){
printf("tid4 create error\n");
return 0;
}
if(pthread_create(&tid5,NULL,task2,NULL)!=0){
printf("tid5 create error\n");
return 0;
}
if(pthread_create(&tid6,NULL,task2,NULL)!=0){
printf("tid6 create error\n");
return 0;
}
printf("tid1:%#lx, tid2:%#lx, tid3:%#lx\ntid4:%#lx, tid5:%#lx, tid6:%#lx\n",tid1,tid2,tid3,tid4,tid5,tid6);
//回收资源
if(pthread_join(tid1,NULL)==0)
printf("tid1回收成功\n");
if(pthread_join(tid2,NULL)==0)
printf("tid2回收成功\n");
if(pthread_join(tid3,NULL)==0)
printf("tid3回收成功\n");
if(pthread_join(tid4,NULL)==0)
printf("tid4回收成功\n");
if(pthread_join(tid5,NULL)==0)
printf("tid5回收成功\n");
if(pthread_join(tid6,NULL)==0)
printf("tid6回收成功\n");
//5. 销毁条件变量
pthread_cond_destroy(&cond);
//55. 销毁锁资源
pthread_mutex_destroy(&fastmutex);
return 0;
}
结果:
4> 将无名管道的代码实现重新敲一遍
代码:
#include<myhead.h>
int main(int argc, char const *argv[])
{
//创建管道文件,并返回该管道文件的文件描述符(最小位分配原则)
int pipefd[2]={0};
if(pipe(pipefd)==1)
PRINT_ERR("");
printf("pipedf[0]=%d,pipefd[1]=%d\n",pipefd[0],pipefd[1]);
//创建一个子进程
pid_t pid=fork();
if(pid>0){
//父进程
//关闭管道的读端
close(pipefd[0]);
char wbuf[128]="";
while(1)
{
bzero(wbuf,sizeof(wbuf)); //清空数组内容
fgets(wbuf,sizeof(wbuf),stdin); //从终端输入数据
wbuf[strlen(wbuf)-1]=0;
//将数据写入管道文件中
write(pipefd[1],wbuf,strlen(wbuf));
//对写入的数据进行判断
if(strcmp(wbuf,"quit")==0)
break;
}
//关闭写端
close(pipefd[1]);
wait(NULL); //阻塞回收子进程资源
}else if(pid==0){
//子进程
//关闭写端
close(pipefd[1]);
char rbuf[128]="";
while(1)
{
//清空rbuf内容
bzero(rbuf,sizeof(rbuf));
//从管道文件中读取数据
read(pipefd[0],rbuf,sizeof(rbuf));
//输出rbuf的数据
printf("父进程传来的数据为:%s\n",rbuf);
//对读取的数据进行判断
if(strcmp(rbuf,"quit")==0)
break;
}
//关闭管道的读端
close(pipefd[0]);
exit(EXIT_SUCCESS); //退出进程
}else
PRINT_ERR("");
return 0;
}
结果:
5> 将有名管道的代码实现重新敲一遍
代码:
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建一个管道文件
if(mkfifo("./myfifo", 0664) == -1)
{
perror("mkfifo error");
return -1;
}
getchar(); //阻塞
system("rm myfifo");
return 0;
}
#include<myhead.h>
int main(int argc, char const *argv[])
{
//打开管道文件
int wfd=1;
//以只写的形式打开文件
if((wfd=open("./myfifo",O_WRONLY))==-1)
PRINT_ERR("");
//定义容器
char wbuf[128]="";
while(1)
{
bzero(wbuf,sizeof(wbuf)); //清空数组内容
fgets(wbuf,sizeof(wbuf),stdin); //从终端输入数据
wbuf[strlen(wbuf)-1]=0;
//将数据写入管道文件中
write(wfd,wbuf,strlen(wbuf));
//对写入的数据进行判断
if(strcmp(wbuf,"quit")==0)
break;
}
return 0;
}
#include<myhead.h>
int main(int argc, char const *argv[])
{
//打开管道文件
int wfd=1;
//以只读的形式打开文件
if((wfd=open("./myfifo",O_RDONLY))==-1)
PRINT_ERR("");
//定义容器
char rbuf[128]="";
while(1)
{
//清空rbuf内容
bzero(rbuf,sizeof(rbuf));
//将数据写入管道文件中
read(wfd,rbuf,sizeof(rbuf));
//输出rbuf的数据
printf("父进程传来的数据为:%s\n",rbuf);
//对读取的数据进行判断
if(strcmp(rbuf,"quit")==0)
break;
}
return 0;
}
结果:
6> 使用有名管道完成两个进程的相互通信(提示:可以使用多进程或多线程完成)
代码:
管道文件创建
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建一个管道文件
if(mkfifo("./myfifo1", 0664) == -1)
{
perror("mkfifo1 error");
return -1;
}
if(mkfifo("./myfifo2", 0664) == -1)
{
perror("mkfifo2 error");
return -1;
}
getchar(); //阻塞
system("rm myfifo1");
system("rm myfifo2");
return 0;
}
线程:
#include<myhead.h>
int main(int argc, char const *argv[])
{
//创建一个子进程
pid_t pid=fork();
if(pid>0){
//父进程
//打开管道文件
int wfd = -1;
//以只写的形式打开文件
if((wfd = open("./myfifo1", O_WRONLY)) == -1)
{
perror("open error");
return -1;
}
//定义容器
char wbuf[128] = "";
while(1)
{
printf("这里是1号机,请输入>>>");
fgets(wbuf, sizeof(wbuf), stdin);
wbuf[strlen(wbuf)-1] = 0;
//将数据写入有名管道
write(wfd, wbuf, strlen(wbuf));
//判断结果
if(strcmp(wbuf,"quit") == 0)
break;
}
//关闭文件
close(wfd);
// wait(NULL); //阻塞回收子进程资源
}else if(pid==0){
//子进程
//打开管道文件
int rfd = -1;
//以只写读的形式打开文件
if((rfd = open("./myfifo2", O_RDONLY)) == -1)
{
perror("open error");
return -1;
}
//定义容器
char rbuf[128] = "";
while(1)
{
//清空数组
bzero(rbuf, sizeof(rbuf));
//读取管道中的数据
read(rfd, rbuf, sizeof(rbuf));
//输出结果
printf("\t\t\t\t\t1号机收到的数据为:%s\n", rbuf);
//判断结果
if(strcmp(rbuf,"quit") == 0)
break;
}
//关闭文件
close(rfd);
exit(EXIT_SUCCESS); //退出进程
}else
PRINT_ERR("");
return 0;
}
#include<myhead.h>
int main(int argc, char const *argv[])
{
//创建一个子进程
pid_t pid=fork();
if(pid>0){
//父进程
//打开管道文件
int rfd = -1;
//以只写读的形式打开文件
if((rfd = open("./myfifo1", O_RDONLY)) == -1)
{
perror("open error");
return -1;
}
//定义容器
char rbuf[128] = "";
while(1)
{
//清空数组
bzero(rbuf, sizeof(rbuf));
//读取管道中的数据
read(rfd, rbuf, sizeof(rbuf));
//输出结果
printf("\t\t\t\t\t2号机收到的数据为:%s\n", rbuf);
//判断结果
if(strcmp(rbuf,"quit") == 0)
break;
}
//关闭文件
close(rfd);
// wait(NULL);
// wait(NULL); //阻塞回收子进程资源
}else if(pid==0){
//子进程
//打开管道文件
int wfd = -1;
//以只写的形式打开文件
if((wfd = open("./myfifo2", O_WRONLY)) == -1)
{
perror("open error");
return -1;
}
//定义容器
char wbuf[128] = "";
while(1)
{
printf("这里是2号机,请输入>>>");
fgets(wbuf, sizeof(wbuf), stdin);
wbuf[strlen(wbuf)-1] = 0;
//将数据写入管道
write(wfd, wbuf, strlen(wbuf));
//判断结果
if(strcmp(wbuf,"quit") == 0)
break;
}
//关闭文件
close(wfd);
exit(EXIT_SUCCESS); //退出进程
}else
PRINT_ERR("");
return 0;
}
结果: