#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc,char *argv[])
{
pid_t pid1,pid2; //进程标识符
pid1 = fork(); //创建一个新的进程
if(pid1<0)
{
printf("创建进程失败!");
exit(1);
}
else if(pid1==0) //如果pid为0则表示当前执行的是子进程
{
printf("子进程1,我将调用exec函数,进程标识符是%d\n",getpid());
execl("/bin/ls","ls","-1","-color",NULL);
printf("exec failed!\n");
exit(1);
}
else //否则为父进程
{
pid2 = fork();//創建一個新的進
if(pid2<0)
{
printf("创建进程失败!");
exit(1);
}
else if(pid2==0) //如果pid为0则表示当前执行的是子进程
{
printf("进程2,我将调用exec函数,进程标识符是%d\n",getpid());
execl("/bin/ls","ls","-1","-color",NULL);
printf("exec failed!\n");
exit(1);
}
else //否则为父进程
{
wait(NULL);
printf("父进程,进程标识符是%d\n",getpid());
printf("完成!\n");
exit(0);
}
}
return 0;
}
运行结果:
分析:
可以看出在使用了exec()函数后程序使用了ls的命令,列出/bin/目录下的文件信息,执行完execl()函数后,子进程调用exit()函数,退出当前进程,而我们可以发现在使用wait()函数后,父进程永远将在其他的子进程完成之后才执行,所以在输出的结果中我们可以看到最后输出的将是父进程的信息。
实验四:利用Linux的信号量机制实现生产者消费者问题(基于进程)。
目的:利用生产者消费者问题更加深刻的理解进程同步与互斥的实现。
几个函数简介:
pthread_create():
函数简介
pthread_create是UNIX环境创建线程函数
头文件
#include<pthread.h>
函数声明
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*(*start_rtn)(void*),void *restrict arg);
返回值
若成功则返回0,否则返回出错编号
参数
第一个参数为指向线程标识符的指针。
第二个参数用来设置线程属性。
第三个参数是线程运行函数的地址。
最后一个参数是运行函数的参数。
pthread_join():
函数简介
函数pthread_join用来等待一个线程的结束。
函数原型为:
extern int pthread_join __P (pthread_t __th, void **__thread_return);
参数:
第一个参数为被等待的线程标识符
第二个参数为一个用户定义的指针,它可以用来存储被等待线程的返回值。
注意
这个函数是一个线程阻塞的函数,调用它的函数将一直等待到被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。如果执行成功,将返回0,如果失败则返回一个错误号。
signal():
SIGINT这个信号是在用户在控制台输入Ctrl+C的时候进程收到的。
signal(SIGINT, &sig_int);这一句指定了收到了SIGINT这个信号以后,处理函数是sig_int
只要在10秒内输入Ctrl+C,屏幕上会打印出"Catch a termination single."
在程序中我用signal()函数作为结束程序的函数按下Ctrl+C退出程序。****
sleep():
就是挂起进程指定的秒数,时间到了返回0。这个函数是我们调节生产者消费者生产和消费能力强弱的函数。
有关信号量sem_t,以及信号量的各个函数的使用的简介可以参考一下博客https://blog.csdn.net/evsqiezi/article/details/8061176
代码部分:
生产者生产过程:
producer()
{
while(生产未完成)
{
.
.
.
生产一个产品;
P(empty)
P(mutex);
送一个产品到有界缓冲区;
v(mutex);
v(full);
}
}
消费者消费过程:
consumer()
{
while(还要继续消费)
{
P(full)
P(mutex);
从有界缓冲区取走产品;
v(mutex);
v(empty);
.
.
.
消费一个产品;
}
}
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<signal.h>
#define producer_N 4//生产者数量
#define consumer_N 5//消费者数量
#define Buffer_N 9//缓冲区大小
int producer_id=0;//生产者ID
int consumer_id=0;//消费者ID
int in=0;//消费者放取产品的位置
int out=0;//消费者放取产品的位置
int Buffer[Buffer_N];//缓冲区
sem_t sem_empty;//同步信号量
sem_t sem_full;//同步信号量
pthread_mutex_t mutex;//互斥信号量
void Signal_print(int signo);//处理信号
void print(); //打印缓冲队列
void *producer();//生产者
void *consumer();//消费者
void main()
{
pthread_t m_producer[producer_N];
pthread_t m_consumer[consumer_N];
int i,ret1[producer_N],ret2[consumer_N];
printf("生产者数目都为4,消费者数目为5,产品缓冲为9,生产者每3秒生产一个产品,消费者每6秒消费一个产品,Ctrl+c退出程序\n");
if(signal(SIGINT,Signal_print)==SIG_ERR)
printf("error signal!\n");
int ru1=sem_init(&sem_empty,0,Buffer_N);//初始化有界缓冲区大小
int ru2=sem_init(&sem_full,0,0);//初始化满缓冲区大小
if(ru1||ru2)
{
printf("error init signal!");
exit(0);
}
int ru3=pthread_mutex_init(&mutex,NULL);
if(ru3)
{
printf("error init thread!\n");
exit(1);
}
// 创建生产者线程
for(i = 0; i < producer_N; i++)
{
ret1[i]= pthread_create(&m_producer[i], NULL, producer, (void *) (&i));
if(ret1[i] != 0) {
printf("生产者%d线程创建失败!\n", i);
exit(1);
}
}
//创建消费者线程
for(i = 0; i < consumer_N; i++)
{
ret2[i]= pthread_create(&m_consumer[i], NULL, consumer, NULL);
if(ret2[i] != 0) {
printf("消费者%d线程创建失败!\n", i);
exit(1);
}
}
//等待线程销毁
for(i = 0; i < producer_N; i++)
pthread_join(m_producer[i], NULL);
for(i = 0; i < consumer_N; i++)
pthread_join(m_consumer[i], NULL);
exit(0);
}
void Signal_print(int signo)//处理信号
{
printf("%d exit applications!\n",signo);
exit(0);
}
void *producer()//生产者
{
int id = producer_id;
while(1)//生产未完成
{
sleep(3);//调节生产者和消费者生产消费的速度
sem_wait(&sem_empty);//p(empty)操作
pthread_mutex_lock(&mutex);//p(mutex)操作
//完成生产者的操作
in%= Buffer_N;
printf("生产者%d将产品放入缓冲区队列第%d号 ",id,in+1);
Buffer[in]=1;
print();
++in;
pthread_mutex_unlock(&mutex);//v(mutex)操作
sem_post(&sem_full);//v(full)操作
}
}
void *consumer()//消费者
{
int id = ++consumer_id;
while(1)//消费未完成
{
sleep(6);//调节生产者和消费者生产消费的速度
sem_wait(&sem_full);//p(full)操作
pthread_mutex_lock(&mutex);//p(mutex)操作
//完成消费者的操作
out%= Buffer_N;
printf("消费者%d从缓冲区队列第%d号取走产品 ",id,out+1);
Buffer[out]=0;
print();
++out;
sem_post(&sem_empty);//v(empty)操作
pthread_mutex_unlock(&mutex);//v(mutex)操作
}
}
// 打印缓冲情况
void print() {
int i;
printf("产品队列为");
for(i = 0; i <Buffer_N; i++)
printf("%d", Buffer[i]);
printf("\n");
}
运行结果:
分析:
初始状态缓冲区为空,此时只允许生产者生产资源放入缓冲区,而消费者试图取缓冲区产品时,将进入等待队列,等待资源释放,在等待队列中的第一个进程将得到资源的控制权。当缓冲区产品满了,P(empty)将拒绝生产者向缓冲区输送资源。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!