Linux 基本语句_9_C语言_生产者&消费者-Toy模板网

这篇具有很好参考价值的文章主要介绍了Linux 基本语句_9_C语言_生产者&消费者。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

完整版生产者代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/file.h> 
#include <string.h>

#define MAXLEN 10
#define ALPHABET 1
#define ALPHABET_START 'a'
#define COUNT_OF_ALPHABET 26
#define DIGIT 2
#define DIGIT_START '0'
#define COUNT_OF_DIGIT 10
#define SIGN_TYPE ALPHABET

const char * fifo_file = "./FIFO.txt";

char buf[MAXLEN];

int lock_set(int fd, int type){
	struct flock old_lock, lock;
	lock.l_whence = SEEK_SET; //加锁区域为文件开始处 
	lock.l_start = 0;//加锁区域在文件位置的相对偏移量 
	lock.l_len = 0;//加锁区域长度 
	lock.l_type = type;//锁的类型 
	lock.l_pid = -1;
	
	fcntl(fd, F_GETLK, &lock);//写入
	
	if(lock.l_type != F_UNLCK){//若未解锁 
	   if(lock.l_type == F_RDLCK){//读取锁 
	   	 printf("Read lock already set by %d\n", lock.l_pid);
	   }
	   else if(lock.l_type == F_WRLCK){
	   	printf("Write lock already set by %d\n", lock.l_pid);
	   } 
	} 
	
	/*上述可能由于不是解锁状态l_type被设置成了相应的锁值下方进行上锁操作时要再次调用type*/ 
	lock.l_type = type;
	
	if((fcntl(fd, F_SETLKW, &lock)) < 0){//上锁失败 
		printf("Lock failed:type  = %d\n", lock.l_type);
		return -1;
	}
	
	switch(lock.l_type){
		case F_RDLCK:
			printf("Read lock set by %d\n", getpid());//获取当前进程的ID
			break;
		case F_WRLCK:
		    printf("Write lock set by %d\n", getpid());
	        break;
		case F_UNLCK:
		    printf("Release lock by %d\n", getpid());//解锁返回1 
			return 1;
			break; 
	}
	
	return 0;//上锁返回0 
}

int product(void){
	int fd;
	unsigned int sign_type, sign_start, sign_count, size;
	static unsigned int counter = 0;//只会执行一次 
	if((fd = open(fifo_file, O_WRONLY|O_APPEND)) < 0){//只写方式打开 ,追加模式 
	   perror("open error");
	   return -1;
    }
    sign_type = SIGN_TYPE;//英文字符集合 
    
    switch(sign_type){
    	case ALPHABET:
		     sign_start = ALPHABEF_START;
			 sign_count = COUNT_OF_ALPHABET;//26
			 break;
		case DIGIT:
		    sign_start = DIGIT_START;
			sign_count = COUNT_OF_DIGIT;
			break;
		default:
		    return -1; 
	}
	
	sprintf(buf, "%c", (sign_start + counter));//将字符写入buf缓冲区
	counter = (counter + 1) % sign_count;
	
	lock_set(fd, F_WRLCK);//写锁
	
	if((size = write(fd, buf, strlen(buf))) < 0){//打开失败，否者写入 
		perror("producer:write error");
		return -1; 
	}
	lock_set(fd, F_UNLCK);//解锁
	
	close(fd);
	return 0; 
}

int main(int argc, const char * argv[]){
	int time_step = 1;//周期 
	int time_life = 10;//生产数量
	
	close(open(fifo_file, O_REONLY|O_CREAT|O_TRUNC, 0664));//创建文件 
	
	if(argc > 1){
		sscanf(argv[1], "%d", &time_step);//将argv[1]转成整数存入time_step中 
	}
	
	if(argc > 2){
		sscanf(argv[2], "%d", &time_life);
	} 
	
	while(time_life --){
		if(product() < 0){
			break;
		} 
		sleep(time_step);
	}
	return 0;
}

流程：
Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

原版代码有点缺失和问题，添加的代码如下：

原版代码缺少创建文件函数，以及没有对文件清空的函数
每次启动一轮生产，为了方便观察将文件上次生产的内容清空：

close(open(fifo_file, O_REONLY|O_CREAT|O_TRUNC, 0664));//创建文件&清空

文件打开模式必须是追加模式，否则生产的新数据会覆盖原有数据：

if((fd = open(fifo_file, O_WRONLY|O_APPEND)) < 0)

运行效果：

FIFO.txt文件上次运行时残留有数据
Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

生产五个数据：
Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法
文件之前生产信息被清除，取而代之的是新数据：

Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

完整版消费者代码：

 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/file.h> 
 #include <string.h>
 
 #define MAX_FILE_SIZE 100 * 1024 * 102
 
 
 const char *fifo_file  = "./FIFO.txt";
                                       
 const char *temp_file = "./temp";
 

int lock_set(int fd, int type){
        struct flock old_lock, lock;
        lock.l_whence = SEEK_SET; //加锁区域为文件开始处 
        lock.l_start = 0;//加锁区域在文件位置的相对偏移量 
        lock.l_len = 0;//加锁区域长度 
        lock.l_type = type;//锁的类型 
        lock.l_pid = -1;

        fcntl(fd, F_GETLK, &lock);//写入

        if(lock.l_type != F_UNLCK){//若未解锁 
              if(lock.l_type == F_RDLCK){//读取锁 
                 printf("Read lock already set by %d\n", lock.l_pid);
              }
             else if(lock.l_type == F_WRLCK){
                 printf("Write lock already set by %d\n", lock.l_pid);
            }
      }                     
     /*上述可能由于不是解锁状态l_type被设置成了相应的锁值下方进行上锁操作时要再次调用type*/ 
    lock.l_type = type;                                         
    if((fcntl(fd, F_SETLKW, &lock)) < 0){//上锁失败             
       printf("Lock failed:type  = %d\n", lock.l_type);
       return -1;
    }
     
    switch(lock.l_type){
        case F_RDLCK:
                    printf("Read lock set by %d\n", getpid());//获取当前进程的ID
                    break;                                                                     
        case F_WRLCK:
                    printf("Write lock set by %d\n", getpid());
                    break;
        case F_UNLCK:
                    printf("Release lock by %d\n", getpid());//解锁返回1 
                    return 1;
                    break;
    }
    return 0;//上锁返回0 
}

int customing(const char * myfifo, int need){
        int fd;
        char buf;
        int counter = 0;
        if((fd = open(myfifo, O_RDONLY)) < 0){//只读 
            perror("FunctI/On customing error");
            return -1;
        }
        printf("Enjoy:");
        lseek(fd, SEEK_SET, 0);
        while(counter < need){
           
           while((read(fd, &buf, 1) == 1) && (counter < need)){//read期望读取的字符数与实际所读一样&&.... 
              fputc(buf, stdout);//打印到显示屏 
              counter ++;
           }
           
        }
        fputs("\n", stdout);
         

        close(fd);
        return 0;
}                                                                                                         

int myfilecopy(const char * sour_file, const char * dest_file, int offset, int count, int copy_mode){
        int in_file, out_file;
        int counter = 0;
        char buff_unit;

        if((in_file = open(sour_file, O_RDONLY|O_NONBLOCK)) < 0){//非阻塞只读 
            perror("FunctI/On my filecopy error int source file\n");
            return -1;
        }

        if((out_file = open(dest_file, O_RDWR|O_CREAT|O_TRUNC|O_NONBLOCK, 0664)) < 0){//非阻塞&打开或创建 
            perror("FUNCTI/O myfilecopy error in destinatI/on file");
            return -1;
        }
        lseek(in_file, offset, SEEK_SET);//设置指针到指定位置

        while((read(in_file, &buff_unit, 1) == 1) && (counter < count)){//读取 
            write(out_file, &buff_unit, 1);//写入 
            counter ++;
        }

        close(in_file);
        close(out_file);
        return 0;
}

 int custom(int need){
         int fd;
         customing(fifo_file, need);//取
 
         if((fd = open(fifo_file, O_RDWR)) < 0){//读写方式打开 
             perror("FunctI/On myfilecopy error in source_file");
             return  -1;
         }
 
         lock_set(fd, F_WRLCK);//上锁，写入锁 
         myfilecopy(fifo_file, temp_file, need, MAX_FILE_SIZE, 0);//将第一个文件内容复制到另一个文件，偏移>
         myfilecopy(temp_file, fifo_file, 0, MAX_FILE_SIZE, 0);
         lock_set(fd, F_UNLCK);//解锁 
 
         unlink(temp_file);//删除 
 
         close(fd);
         return 0;
 }

 int main(int argc, const char *argv[]){
         int customer_capacity = 0;
 
             if(argc > 1){
                sscanf(argv[1], "%d", &customer_capacity);//消费数目写入 
             }
 
             if(customer_capacity > 0){
               custom(customer_capacity);
             }
 
             return 0;
 }

流程：
Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

这里对open函数进行再次扩充讲解：

当文件被一个进程植入写入锁的时候，另一个进程仍可以通过open函数获取该文件的标志位，但却不能进行read或write函数操作，因为会受到写入锁的阻止

朴素的将写入锁是阻止其他进程对文件的读写操作，而不是open操作

Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法
之前一直不理解为什么customing函数中下列语句不会报错，通过用printf函数取点才发现问题

if((fd = open(myfifo, O_RDONLY)) < 0){//只读 
        perror("FunctI/On customing error");
        return -1;
}

看来看课本和懂课本是天差地别的

还有一点注意的是：

生产者代码中的：

while(time_life --){
	if(product() < 0){
		break;
	} 
	sleep(time_step);
}

其中：

sleep(time_step);

这个延时语句作用巨大：

lock_set(fd, F_WRLCK);//上锁，写入锁 
myfilecopy(fifo_file, temp_file, need, MAX_FILE_SIZE, 0);//将第一个文件内容复制到另一个文件，偏移>
myfilecopy(temp_file, fifo_file, 0, MAX_FILE_SIZE, 0);
lock_set(fd, F_UNLCK);//解锁

其作用是为了让消费者中这个文件挪动语句能有时间完成
同时也用于读取生产出来的字符：

while((read(in_file, &buff_unit, 1) == 1) && (counter < count)){//读取 
        write(out_file, &buff_unit, 1);//写入 
        counter ++;
    }

上述语句在字符未被生产，或者文件被锁住，会一直等待，直到解锁或者有字符被生产

例如文件中生产abc,消费a,所以挪位后为bc

效果：

已生产五个字符：
Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

消费四个：
Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

最后剩一个：

Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法

同时进行如下：

Linux 基本语句_9_C语言_生产者&消费者,linux,c语言,算法
整个文件被锁住，只出现在生产者将生产的字符写入文件和文件挪动这俩操作文章来源地址https://www.toymoban.com/news/detail-725775.html

到了这里，关于Linux 基本语句_9_C语言_生产者&消费者的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

Linux 基本语句_9_C语言_生产者&消费者

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2