【操作系统实验】---shell、多线程、信号量实验报告

已于 2022-06-14 10:16:24 修改
阅读量585 收藏 3
点赞数 1
分类专栏： 操作系统 文章标签： 操作系统 c++ linux
于 2022-06-12 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46112690/article/details/125173530
版权
操作系统实验报告

文章目录

job6/sh3.c

题目要求

实现shell程序，要求支持基本命令、重定向命令、管道命令、后台命令。

解决思路

  1. type类型有TREE_BASICTREE_ASYNC,TREE_PIPE,TREE_REDIRECT,TREE_BASIC,TREE_TOKEN五种，分别是后台类型，管道类型，重定向类型，基本类型，叶子节点。tree_t结构体的type存放类型，token存放叶子节点的单词，child_count孩子数量（比如类型为TREE_PIPE的节点有两个孩子子树）,child_vector指向子树；
  2. 根据节点类型不同，选择不同的子节点存放方式：
    • 每个type为TREE_BASIC的子节点中存放单词;
    • 每个type为TREE_REDIRECT的第一个子节点中存放“>”或">>“或”<"，其他节点中存放basic节点；
    • 每个type为TREE_PIPE的两个子节点中存放对应节点（可以是basic\redirect\pipe）；
    • 如果type为TREE_ASYNC,一定是最后一个节点。
  3. 从根节点开始，每个节点tree_t执行exec；
  4. 在exec中通过type进行判断：
    • 如果是TREE_PIPE,执行exec_pipe,exec_pipe中将 "|"左边的输出重定向至管道的写端，将“|”右边的输入重定向至管道的读端；
    • 如果是TREE_REDIRECT,执行exec_redirect,exec_redirect判断这个节点的第一个子节点，可能为“>”或“>>”或“<”，分别执行写文件重定向至标准输出、追加文件重定向至标准输出、读文件重定向至标准输入。
    • 如果是TREE_BASIC,执行exec_basic,除了“cd”、"pwd"操作，其他使用execvp()函数执行操作。
  5. 在main中，如果某节点类型为TREE_ASYNC，则不等待子进程结束，就可以执行下一个循环，以此实现后台命令。

关键代码

基本操作的执行，如果是cd操作就直接退出，pwd操作使用getcwd获取路径，其他的命令使用execvp装入程序

void exec_basic(tree_t *command_tree)
{
	if(strcmp(command_tree->child_vector[0]->token, "cd") == 0)
	{
		return;
	}
	else if(strcmp(command_tree->child_vector[0]->token, "pwd") == 0)
	{
		char *path = getcwd(NULL, 0);
		printf("%s\n", path);
		free(path);
		// exit(0);
	}
	else
	{
		int argc = command_tree->child_count;
		char *argv[argc+1];
		for(int i=0; i<argc; i++){
		argv[i] = command_tree->child_vector[i]->token;
		}
		argv[argc] = NULL;
		int error = execvp(argv[0], argv);
		if(error < 0)
		{
			perror(argv[0]);
		}
	}

}

管道操作，左子树的输出重定向到管道的写端，右子树的输入重定向到管道的读端。

void exec_pipe(tree_t *command_tree)
{
	int fd[2];
	int pid;
	pipe(fd);
	pid = fork();
	if(pid == 0){
		dup2(fd[1], 1);
		close(fd[0]);
		close(fd[1]);
		exec(command_tree->child_vector[0]);
		exit(0);
	}
	wait(NULL);
	dup2(fd[0], 0);
	close(fd[0]);
	close(fd[1]);
	exec(command_tree->child_vector[1]);
}

重定向操作，第一个孩子的token为“<”，打开文件读；为“>”，打开文件写；为“>>”，打开文件追加。

void exec_redirect(tree_t *command_tree)
{
	int fd;
	if(strcmp(command_tree->child_vector[1]->token, "<") == 0)
	{
		fd = open(command_tree->child_vector[2]->token, O_RDONLY, 0666);
		dup2(fd, 0);
		close(fd);
	}
	else if(strcmp(command_tree->child_vector[1]->token, ">") == 0)
	{
		fd = open(command_tree->child_vector[2]->token, O_CREAT|O_RDWR, 0666);
		dup2(fd, 1);
		close(fd);
	}
	else
	{
		fd = open(command_tree->child_vector[2]->token, O_APPEND|O_CREAT|O_RDWR, 0777);
		dup2(fd, 1);
		close(fd);
	}
	exec(command_tree->child_vector[0]);

}

执行代码

void exec(tree_t *command_tree)
{
	switch(command_tree->type)
	{
		case TREE_BASIC:
			exec_basic(command_tree);
			break;
		case TREE_PIPE:
			exec_pipe(command_tree);
			break;
		case TREE_REDIRECT:
			exec_redirect(command_tree);
			break;
		default:
			break;

	}

mian函数,循环接收输出的指令，根据指令构建语法树，exit指令就结束程序，cd指令就调用chdir,其他指令使用子进程调用exec，后台命令就不用等待子进程结束。

int main()
{
	char line[SIZE];
	int count;
	while(1){
		write(1, ">", sizeof(">"));
		count = read(0, line, sizeof(line)) -1;
		line[count] = 0;

		char *word_array[MAX_ARGC];
		int word_count = split(line, " ", word_array);


		tree_t *root = func(word_array, word_count);
		// tree_print(root,0);
		int async = 0;
		if(root->type == TREE_ASYNC){
			async = 1;
			root = root->child_vector[0];
		}

		if(root->child_vector[0]->token != NULL && strcmp(root->child_vector[0]->token, "exit") == 0){
			exit(0);
		}
		if(root->child_vector[0]->token != NULL && strcmp(root->child_vector[0]->token, "cd") == 0){
//			printf("cd\n");
			int error = chdir(root->child_vector[1]->token);
			if(error < 0){
				perror("cd");
			}
		}
		else{
			pid_t pid = fork();
			if(pid == 0){
				exec(root);
			}
		}
		if(!async)
			wait(NULL);
	}

	return 0;
}

运行结果

实现了shell程序，支持基本命令、重定向命令、管道命令、后台命令。

//基本输入
echo abc ddd
//输出
abc ddd

//重定向输入
echo abc >log
//输出
log文件中内容:abc

//管道输入
cat </etc/passwd | wc -l >log
//输出
log文件中内容:29

//后台输入
cat /etc/passwd >log &
//输出
log文件中内容是/etc/passwd中的内容

job7/pi2.c

题目要求

使用N个线程根据莱布尼兹级数计算PI

  • 能适应N个核心
  • 主线程创建N个辅助线程
  • 每个辅助线程计算一部分任务，并将结果返回
  • 主线程等待N个辅助线程运行结束，将所有辅助线程的结果累加
  • 本题要求 1: 使用线程参数，消除程序中的代码重复
  • 本题要求 2: 不能使用全局变量存储线程返回值

解决思路

  1. 在main中创建多个子线程，每个子线程执行compute ,子线程参数为param结构体,param中有compute累加需要的start与end参数；
  2. 在compute函数中，初始化sum=0，i从param->start开始增加，判断i,若i是奇数且i+1是4的倍数，sum减去i的倒数，若i是奇数且i+1不是4的倍数，sum加上i的倒数。循环直到i等于param->end，返回sum；
  3. main中等待所有子线程结束，获得所有子线程的返回值，将所有返回值累加再乘以4，则得到PI；
  4. 每个子线程的start与end由核心数CORE_N与END决定。

关键代码

参数结构体，返回值结构体

struct param{
	int start;
	int end;
};
struct result{
	double sum;
};

计算函数
i从param->start开始增加，判断i,若i是奇数且i+1是4的倍数，sum减去i的倒数，若i是奇数且i+1不是4的倍数，sum加上i的倒数。循环直到i等于param->end，返回sum。

void *compute(void *arg)
{
	struct param *param;
	struct result *result;
	double sum = 0;
	param = (struct param *)arg;
	for(int i=param->start;i<param->end;i++)
	{
		double num = i;
		if(i%2==1)
		{
			if((i+1)%4==0)
			{
			//	printf("-1/%d",i);
				sum-=1.0/num;
			}
			else
			{
			//	printf("+1/%d",i);
				sum+=1.0/num;
			}
		}
	}
	result = malloc(sizeof(struct result));
	result->sum = sum;
	return result;
}

主函数循环创建多个子线程，并等待子线程结束获得返回值，计算得PI。

int main()
{
	pthread_t worker_tids[CORE_N];
	struct param params[CORE_N];
	double total=0;
	for(int i=0;i<CORE_N;i++)
	{
		struct param *param;
		param = &params[i];
		param -> start = i*END/CORE_N;
		param -> end = (i+1)*END/CORE_N;
		pthread_create(&worker_tids[i],NULL,compute,param);
	}
	for(int i=0;i<CORE_N;i++)
	{
		struct result *result;
		pthread_join(worker_tids[i],(void**)&result);
	//	printf("CPU%d sum = %f\n",i,result->sum);
		total += result->sum;
		free(result);
	}
	total*=4;
	printf("pi = %f\n",total);
	return 0;
}

运行结果

当END取9999，CORE_N 取 10时，

结果为：PI=3.141793

job8/pc.c

题目要求

使用条件变量解决生产者、计算者、消费者问题

  • 系统中有3个线程：生产者、计算者、消费者
  • 系统中有2个容量为4的缓冲区：buffer1、buffer2
  • 生产者
    • 生产’a’、‘b’、‘c’、‘d’、‘e’、‘f’、‘g’、'h’八个字符
    • 放入到buffer1
    • 打印生产的字符
  • 计算者
    • 从buffer1取出字符
    • 将小写字符转换为大写字符，按照 input:OUTPUT 的格式打印
    • 放入到buffer2
  • 消费者
    • 从buffer2取出字符
    • 打印取出的字符
  • 程序输出结果(实际输出结果是交织的)
    a
b
c
...
    a:A
    b:B
    c:C
    ...
            A
            B
            C
            ...

解决思路

  1. 创建两个缓冲区，buffer1中存放小写字母，buffer2中存放大写字母；
  2. get_item1()与put_item1()对buffer1进行操作，get_item2()与put_item2()对buffer2进行操作，
    buffer1_is_empty()与buffer1_is_full()对buffer1进行判断，buffer2_is_empty()与buffer2_is_full()对buffer2进行判断；
  3. main函数中创建子线程compute_tid与consumer_tid,入口函数分别是compute()与consume();
  4. 主线程调用produce()，如果buffer1是满的，则等待条件变量wait_empty_buffer1，向buffer1中放入产生的字母，并将发出buffer1满的信号；
  5. 子线程computer_tid调用compute()，buffer1是空的，则等待条件变量wait_full_buffer1，从buffer1中取出字母，并将发出buffer1空的信号。buffer2是满的则，等待条件变量wait_empty_buffer2，将小写字母转换为大写字母，向buffer2中放入产生的大写字母，并将发出buffer2满的信号；
  6. 子线程consumer_tid调用consume()，buffer2是空的，则等待条件变量wait_full_buffer2，从buffer2中取出字母，并将发出buffer2空的信号；
  7. main函数等待所有子线程结束再结束。

关键代码

生产者
互斥访问buffer1，等待条件变量wait_empty_buffer1，产生小写字母。

void *produce(void *arg)
{
	int i;
	int item;

	for(i=0;i < ITEM_COUNT;i++)
	{
		pthread_mutex_lock(&mutex_pc);
		while(buffer1_is_full())
		{
			pthread_cond_wait(&wait_empty_buffer1,&mutex_pc);
		}
		item = 'a' + i;
		put_item1(item);
		printf("%c\n",item);

		pthread_cond_signal(&wait_full_buffer1);
		pthread_mutex_unlock(&mutex_pc);

	}
	return NULL;

}

计算者
互斥访问buffer1，等待条件变量wait_full_buffer1，获取小写字母。
互斥访问buffer2，等待条件变量wait_empty_buffer2，产生大写字母。

//a:A
void *commpute(void *arg)
{
	int i;
	int item,ITEM;

	for(i=0;i<ITEM_COUNT;i++)
	{
		pthread_mutex_lock(&mutex_pc);
		while(buffer1_is_empty())
		{
			pthread_cond_wait(&wait_full_buffer1,&mutex_pc);
		}
		item = get_item1();
		pthread_cond_signal(&wait_empty_buffer1);
		pthread_mutex_unlock(&mutex_pc);

		pthread_mutex_lock(&mutex_cc);
		while(buffer2_is_full())
		{
			pthread_cond_wait(&wait_empty_buffer2,&mutex_cc);
		}
		ITEM = item+'A'-'a';
		put_item2(ITEM);
		printf("\t%c:%c\n",item,ITEM);
		pthread_cond_signal(&wait_full_buffer2);
		pthread_mutex_unlock(&mutex_cc);
	}
	return NULL;
}

消费者
互斥访问buffer2，等待条件变量wait_full_buffer2，获取大写字母。

void *consume(void *arg)
{
	int i;
	int item;
	for(i = 0;i<ITEM_COUNT;i++)
	{
		pthread_mutex_lock(&mutex_cc);
		while(buffer2_is_empty())
		{
			pthread_cond_wait(&wait_full_buffer2,&mutex_cc);
		}
		item = get_item2();
		printf("\t\t%c\n",item);
		pthread_cond_signal(&wait_empty_buffer2);
		pthread_mutex_unlock(&mutex_cc);
	}
	return NULL;
}

主函数
初始化互斥量、条件变量，创建子线程执行计算与消费，调用生产者，等待所有线程结束。

int main()
{

	pthread_t computer_tid;
	pthread_t consumer_tid;

	pthread_mutex_init(&mutex_pc,NULL);
	pthread_mutex_init(&mutex_cc,NULL);

	pthread_cond_init(&wait_empty_buffer1,NULL);
	pthread_cond_init(&wait_full_buffer1,NULL);
	pthread_cond_init(&wait_empty_buffer2,NULL);
	pthread_cond_init(&wait_full_buffer2,NULL);


	pthread_create(&computer_tid,NULL,commpute,NULL);
	pthread_create(&consumer_tid,NULL,consume,NULL);

	produce(NULL);
	pthread_join(computer_tid,NULL);
	pthread_join(consumer_tid,NULL);

	return 0;
}

运行结果

a
b
c
d
	a:A
		A
e
	b:B
		B
f
	c:C
		C
g
	d:D
		D
h
	e:E
	f:F
	g:G
		E
		F
		G
	h:H
		H

job9/pc.c

题目要求

使用信号量解决生产者、计算者、消费者问题

  • 系统中有3个线程：生产者、计算者、消费者
  • 系统中有2个容量为4的缓冲区：buffer1、buffer2
  • 生产者
    • 生产’a’、‘b’、‘c’、‘d’、‘e’、‘f’、‘g’、'h’八个字符
    • 放入到buffer1
    • 打印生产的字符
  • 计算者
    • 从buffer1取出字符
    • 将小写字符转换为大写字符，按照 input:OUTPUT 的格式打印
    • 放入到buffer2
  • 消费者
    • 从buffer2取出字符
    • 打印取出的字符
  • 程序输出结果(实际输出结果是交织的)
    a
b
c
...
    a:A
    b:B
    c:C
    ...
            A
            B
            C
            ...

解决思路

  1. 创建两个buffer，buffer1中存放小写字母，buffer2中存放大写字母；
  2. get_item1()与put_item1()对buffer1进行操作，get_item2()与put_item2()对buffer2进行操作，
    buffer1_is_empty()与buffer1_is_full()对buffer1进行判断，buffer2_is_empty()与buffer2_is_full()对buffer2进行判断；
  3. 建立信号量sema_t结构体，包含信号量的值、互斥量、条件变量。
    • sema_init():信号量初始化，
    • sema_wait():如果信号量的值小于等于0，则等待条件变量,将信号量的值减一
    • sema_signal():将信号量的值加一,唤醒等待条件变量的线程
  4. mutex1_sema 、 mutex2_sema用于互斥访问共享缓冲区变量in1、out1、in2、out2
  5. empty_buffer1_sema、full_buffer1_sema、empty_buffer2_sema、full_buffer3_sema用于线程同步；
  6. 主线程调用produce()，生产者需要一个空的buffer1，申请信号量empty_buffer1_sema，mutex1_sema用于对共享变量进行互斥访问，生产者线程生产一个数据后产生一个新的满buffer1，释放信号量full_buffer1_sema。
  7. 子线程computer_tid调用compute()：
    • full_buffer1_sema的数值表示空buffer的数量，消费者需要一个满的buffer1，申请请信号量full_buffer1_sema，mutex1_sema用于对共享变量进行互斥访问，消费者线程取走一个数据后，产生一个新的空buffer1，释放信号量empty_buffer1_sema。
    • 将小写字母转换为大写字母。
    • 还需要一个空的buffer2，申请信号量empty_buffer2_sema，mutex2_sema用于对共享变量进行互斥访问，生产者线程生产一个数据后产生一个新的满buffer2，释放信号量full_buffer2_sema。
  8. 子线程consumer_tid调用consume()，full_buffer2_sema的数值表示空buffer的数量，消费者需要一个满的buffer2，申请请信号量full_buffer2_sema，mutex2_sema用于对共享变量进行互斥访问，消费者线程取走一个数据后，产生一个新的空buffer2，释放信号量empty_buffer2_sema。
  9. 初始化信号量，创建消费者线程，主线程作为生产者，执行produce函数，子线程compute_tid与consumer_tid,入口函数分别是compute()与consume()。main函数等待所有子线程结束再结束。

关键代码

生产者
等待信号量empty_buffer1_sema，等待信号量mutex1_sem，产生小写字母。

void *produce(void *arg)
{
	int i;
	int item;
	for(i=0;i<ITEM_COUNT;i++)
	{
		sema_wait(&empty_buffer1_sema);
		sema_wait(&mutex1_sema);

		item = i+'a';
		put_item1(item);
		printf("%c\n",item);
		sema_signal(&mutex1_sema);
		sema_signal(&full_buffer1_sema);
	}
	return NULL;
}

计算者
等待信号量full_buffer1_sema，等待信号量mutex1_sem，获取小写字母。
等待信号量empty_buffer2_sema，等待信号量mutex2_sem，产生大写字母。

void *commpute(void *arg)
{
	int i;
	int item;
	int ITEM;

	for(i=0;i<ITEM_COUNT;i++)
	{
		sema_wait(&full_buffer1_sema);
		sema_wait(&mutex1_sema);

		item = get_item1();
		ITEM = item+'A'-'a';
//		printf("commpute:%c\n",item);
		printf("\t %c:%c\n",item,ITEM);

		sema_signal(&mutex1_sema);
		sema_signal(&empty_buffer1_sema);


		sema_wait(&empty_buffer2_sema);
		sema_wait(&mutex2_sema);

		put_item2(ITEM);

		sema_signal(&mutex2_sema);
		sema_signal(&full_buffer2_sema);
	}
	return NULL;
}

消费者
等待信号量full_buffer2_sema，等待信号量mutex2_sem，获取大写字母。

void *consume(void *arg)
{
	int i;
	int item;

	for(i=0;i<ITEM_COUNT;i++)
	{
		sema_wait(&full_buffer2_sema);
		sema_wait(&mutex2_sema);

		item = get_item2();
		printf("\t\t%c\n",item);
		sema_signal(&mutex2_sema);
		sema_signal(&empty_buffer2_sema);
	}
	return NULL;
}

主函数
初始化信号量，创建子线程执行计算与消费，调用生产者，等待所有线程结束。

int main()
{
	pthread_t commpute_tid;
	pthread_t consume_tid;
	sema_init(&mutex1_sema,1);
	sema_init(&mutex2_sema,1);
	sema_init(&empty_buffer1_sema,CAPACITY-1);
	sema_init(&full_buffer1_sema,0);
	sema_init(&empty_buffer2_sema,CAPACITY-1);
	sema_init(&full_buffer2_sema,0);
	pthread_create(&commpute_tid,NULL,commpute,NULL);
	pthread_create(&consume_tid,NULL,consume,NULL);
	produce(NULL);
	pthread_join(commpute_tid,NULL);
	pthread_join(consume_tid,NULL);
	return 0;
}

运行结果

a
b
c
d
	a:A
		A
e
	b:B
		B
f
	c:C
		C
g
	d:D
		D
h
	e:E
	f:F
	g:G
		E
		F
		G
	h:H
		H

job10/pfind.c

题目要求

  1. 功能
  • 功能与 sfind 相同
  • 要求使用多线程完成
    • 主线程创建若干个子线程
      • 主线程负责遍历目录中的文件
      • 遍历到目录中的叶子节点时
      • 将叶子节点发送给子线程进行处理
    • 两者之间使用生产者消费者模型通信
      • 主线程生成数据
      • 子线程读取数据
  1. 图示
  • 主线程创建 2 个子线程
    • 主线程遍历目录 test 下的所有文件
    • 把遍历的叶子节点 path 和目标字符串 string，作为任务，发送到任务队列
  • 子线程
    • 不断的从任务队列中读取任务 path 和 string
    • 在 path 中查找字符串 string

在这里插入图片描述

解决思路

  1. buffer格式为task结构体，task存储is_end判断是否是最后一个文件,path找到的文件的路径,string含有要查找单词的行；
  2. buffer_is_empty()与buffer_is_full()对buffer进行判断，mutex对buffer进行互斥访问， wait_empty_buffer、wait_full_buffer两个条件变量用于存buffer、取buffer。
  3. 在get_item与put_item中互斥访问buffer:
    • get_item中，如果buffer_is_empty,要等条件变量wait_full_buffer再取文件，并设置wait_empty_buffer
    • put_item中，如果buffer_is_full,要等条件变量wait_empty_buffer再存文件，并设置wait_full__buffer。
  4. 在文件中查找含有单词的行，逐行读取文件，再使用strstr()即可；
  5. 子线程入口函数worker_entry中有get_item,获取要处理的文件，如果是最后一个文件，在结束子进程之前，再向buffer中放入一个is_end=1的task,让其他的子进程也可以结束。
  6. 主线程要找出某目录下所有的文件，使用find_dir函数，opendir()进入目录，判断每个元素，是文件就执行put_item放入buffer,是目录就加入目录名字递归查找。
  7. 主函数 先判断目标路径是不是文件，是文件就直接find_file,不是就find_dir。添加一个is_end=1的task作为结束的元素，再创建多个子进程，每个子进程通过worker_entry处理文件。等待子进程结束。

关键代码

读写buffer

struct task get_item()
{
	struct task item;
	pthread_mutex_lock(&mutex);
	while(buffer_is_empty())
	{
		printf("wait_full\n");
		pthread_cond_wait(&wait_full_buffer,&mutex);
	}
	item = buffer[out];
	out = (out+1)% CAPACITY;
	pthread_cond_signal(&wait_empty_buffer);
	pthread_mutex_unlock(&mutex);
	return item;
}

void put_item(struct task item)
{
	pthread_mutex_lock(&mutex);
	while(buffer_is_full())
	{
		pthread_cond_wait(&wait_empty_buffer,&mutex);
	}
	buffer[in]=item;
	in = (in+1)%CAPACITY;
	pthread_cond_signal(&wait_full_buffer);
	pthread_mutex_unlock(&mutex);
}

找文件，找到文件放入buffer

void find_dir(char *path,char *target)
{
	DIR *dir = opendir(path);
	struct dirent *entry;
	struct task buffer;
	while(entry = readdir(dir)){
		if(strcmp(entry->d_name,".") == 0)
			continue;
		if(strcmp(entry->d_name,"..") == 0)
			continue;
		if(entry->d_type == DT_DIR)
		{
			char base[80];
			memset(base,'\0',sizeof(base));
			strcpy(base,path);
			strcat(base,"/");
			strcat(base,entry->d_name);
//			printf("base:%s\n",base);
			find_dir(base,target);

		}
		if(entry->d_type == DT_REG)
		{
			char base[80];
			memset(base,'\0',sizeof(base));
			strcpy(base,path);
			strcat(base,"/");
			strcat(base,entry->d_name);
			//join array
			buffer.is_end=0;
			strcpy(buffer.path,base);
			strcpy(buffer.string,target);
			put_item(buffer);
//			printf("put_item\n");
			break;
		}
	}
	closedir(dir);

}

主函数，如果输入的是路径，找出所有文件，给buffer,创建子线程，查找含单词的行。

int main(int argc,char *argv[])
{
	char *path = argv[1];
	char *string = argv[2];

	if(isfile(path))
	{
		find_file(path,string);
		return 0;
	}
	pthread_t consumer_tid[WORKER_NUMBER];
	find_dir(path,string);
	struct task buf;
	buf.is_end=1;
	put_item(buf);

	//create
	for(int i=0;i<WORKER_NUMBER;i++)
	{
		pthread_create(&consumer_tid[i],NULL,worker_entry,NULL);

	}
	//is_end

	//exit
	for(int i=0;i<WORKER_NUMBER;i++)
	{

		pthread_join(consumer_tid[i],NULL);
	}

	return 0;
}

运行结果

指令：
./a.out test/world/world.c int
输出：

test/world/world.c: 			printf("%s: %s",path,line);
test/world/world.c: 			printf("dir %s\n",entry->d_name);
test/world/world.c: 			printf("file %s\n",entry->d_name);
test/world/world.c: int main(int argc,char *argv[])

指令：
./a.out test main
输出：

test/world/world.c: int main(int argc,char *argv[])
test/hello/hello.c: int main(int argc,char *argv[])

总结

在本学期的操作系统实验这门课学习当中，为了更好的了解操作系统相关知识，我们在Linux系统做了10个实验。在实验的过程中，我对课堂上学到的操作系统的一些知识有了新的认识，通过实验动手写shell让我深入了解了命令执行原理，通过代码实现了生产者-消费者加深了我对条件变量、信号量的理解，收获颇丰。

子衿JDD
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Shell 实现多线程（多任务）
weixin_34203426的博客
08-21 914
实现方案： 1.命令结尾添加：&amp; #/bin/bash all_num=10 a=$(date +%H%M%S) for num in `seq 1 ${all_num}` do { sleep 1 echo ${num} } &amp; done b=$(date +%H%M%S) echo -e "startTime:\t$a" echo ...
山东大学操作系统实验
01-05
山东大学的操作系统实验旨在让学生深入理解操作系统的基本概念和原理，通过实践来提升理论知识的应用能力。实验内容包括进程控制、线程与管道通信、Shell编程以及进程同步和互斥等关键领域。 实验一：进程控制 在这...
shell多线程
陈贤鹏的博客
08-15 580
使用&amp;和wait结合   #!/bin/bash for ((i=0;i&lt;10;i++));do { sleep 3; echo "sleep" } &amp;         #{}内的命令放在后台执行 done wait      #等待子线程结束
shell 实现子进程多任务，进程高并发
m0_61066945的博客
06-20 1254
shell实现高并发、shell子进程随主进程退出而退出、shell强制停止子进程
用信号量实现进程同步与互斥（含代码分析）
m0_58323186的博客
11-26 1340
信号量简单的来说就是一个变量，代表着系统中互斥资源的数量，通常用原语来实现对信号量机制的操作。一对原语：wait(S)也称为P操作，singnal(S)也称为V操作。weakup(S.L)//如果还有资源在等待则唤醒等待资源的进程。//如果此时没有空闲临界资源则一直循环等待。//如果此时剩余资源不足则进入阻塞状态。//如果资源够用占用一个资源。//信号量变量，表示临界资源的数量。//使用完资源后释放一个资源。void signal(S){//相当于退出区。void wait(S）{//相当于进入区。
操作系统大作业---信号量+shell脚本+socket
ZZU_LGY
04-21 1385
分析过程：分析中涉及到一个问题1210运行结果当生产一个车轮和车架所用时间一样，都为1s时，可以看出车轮明显不够用，车架过载因此把车轮和车架生产时间改为1：2，就会出现车轮和车架趋于平稳，不会造成挤压。2、编写一个用于检查关于命令“lspxct"的实验报告的Shell脚本，该脚本检查命令的执行结果中是否存在包含“px”和“ct”的文件或目录，显示包含“px”的文件或目录数，包含“ct”的文件或目录数。如果两者的文件或目录数均大于0，则对该实验项目给予100分。
操作系统之信号量机制
拿头去拼啊
11-09 1502
信号量机制可用来解决互斥与同步问题，它只能被两个标准原语（执行过程中不可以被中断，通常可由硬件来实现）wait(S)和signal(S)访问，也可以记作“P操作（wait）”和“V操作（signal）”。 原语的操作类似TestAndSet，Swap和关中断在我的另一篇文章有写到《操作系统之进程同步问题》中有叙述到。 原语之所以不能被中断，是因为原语对变量的操作过程如果被打断，可能会去允许另一个对同一变量的操作过程，从而出现临界段问题。若能够找到一种解决临界段问题的元方法（原语），就可以实现对共享变量操
厦大-unix程序设计课实验作业.zip
最新发布
06-02
在Unix环境下，程序设计涉及到的知识点广泛且深入，它不仅是操作系统的一部分，也是软件开发的重要基石。以下将分别针对week1至week5的作业内容，解析可能涵盖的关键知识点。 1. **Week1：基础命令与Shell脚本** -...
SCUT 操作系统实验
01-06
操作系统是计算机科学的基础，而SCUT（华南理工大学）的操作系统实验则是为了帮助学生深入理解这一核心概念。在Linux环境下，这个实验涵盖了四个关键主题：进程、线程、系统调用和shell。以下是对这些主题的详细说明...
操作系统实验 华工 Linux
12-21
操作系统是计算机科学的基础课程之一，尤其在华工（华南理工大学）这样的知名高校，Linux操作系统的学习是必不可少的部分。这里我们将深入探讨四个实验，分别是进程与线程的创建、进程与线程同步与互斥、文件查找...
操作系统实验-信号量机制实现进程同步
06-16
这是一个利用信号量机制实现进程同步的模拟程序，如你有更好的方法或觉的我的可以修改欢迎交流学习。
OS-SL2-Assignments：我的所有OS（SL2）分配，TEIT，SPPU
02-04
5. **线程与并发**：掌握线程的创建、同步和通信机制，如互斥锁、信号量、条件变量等，并理解临界区和死锁问题。 6. **操作系统的安全性和权限管理**：了解用户权限、访问控制列表（ACL）和访问控制矩阵，以及如何...
shell--trap
evsqiezi
02-28 759
trap      trap 是shell自带的捕获信号量的指令。trap命令用于指定在接收到信号后将要采取的动作。常见的用途是在脚本程序被中断时完成清理工作。 一、关于信号 历史上，shell总是用数字来代表信号，而新的脚本程序应该使用信号的名字，它们保存在用#include命令包含进来的signal.h头文件中，在使用信号名时需要省略SIG前缀。 kill和trap等都可以看到
使用格雷戈里公式求pi的近似值
空林长风博客
03-18 6503
问题背景： 输入一个精度e,使用格雷戈里公式计算pi的近似值。 格雷戈里公式： 解决方案： 首先定义函数funpi(e)用来求pi的近似值。 使精确度精确到最后一项的绝对值小于e。 使用do-while循环控制是否需要持续输入。 程序源代码： #include<stdio.h> #include<math.h> double funpi(double e);//函数声明 int main(void) { char ch; double e,pi; do{ prin
Linux实验报告四-shell编程
&1=1的博客
05-05 5557
1、建立脚本文件1.sh，编写一段代码，实现以下功能：输出200以内能被7整除的所有数，并求其和。分别用while语句、for语句、until语句实现。 代码： touch 1.sh vim 1.sh chnod a+x 1.sh cat 1.sh 脚本代码： 方法一：使用while语句 #! /bin/bash i=0 sum=0 while [ "$i" -le "200" ] do let "z=i%7" if[ "$z"-eq 0 ] then echo "$i" let "sum += i" f
Linux学习笔记（共享内存 +⽂件锁 + 信号量 +Shell脚本编程 +云服务器⼊⻔）之信号量 +Shell脚本编程
qq_39907680的博客
10-22 408
信号量  概念  为了保证共享内存不会同时被多⼈修改从⽽造成不同步，⼀般使⽤信号量。  示例       新建信号量           int semget（key_t key，int nsems，int semflg）;       修改信号量的值  ----------------------- Page 7 -----------------------        in...
求π的近似值
llebck的博客
12-15 1629
#include /*分数:fractions分子:numerator分母:denominator*/   main(){ double sum,sign,i,s;  sum=1.0;i=1.0;s=1.0;  for(;1/i>1e-6;i=i+2.0){ sign=1.0/(i+2.0); s=-s;/*技巧用单独的一个变量控制+ -*/  sum=sum+sign*s; }
查询linux信号量命令,linux下的trap命令和SIGHUP信号量详解。
weixin_36239768的博客
04-29 843
19) SIGSTOP 停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别: 该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略.20) SIGTSTP 停止进程的运行, 但该信号可以被处理和忽略. 用户键入SUSP字符时(通常是Ctrl-Z)发出这个信号21) SIGTTIN 当后台作业要从用户终端读数据时, 该作业中的所有进程会收到SIGT...
实验 5:chcore操作系统- 文件系统与shell
12-29
在实验5中，我们学习了Chcore操作系统中的文件系统和shell。文件系统是操作系统中管理文件和文件夹的重要组成部分，它需要能够对文件进行管理、存储和检索。而shell则是用户和操作系统之间的交互界面，用户可以通过shell来执行命令、管理文件和进行其他操作。 在本次实验中，我们首先了解了文件系统的基本概念和原理，包括文件和目录的组织结构、文件存储方式以及文件系统的层次结构。我们学习了如何创建文件和目录，以及如何对它们进行删除、移动和复制等操作。通过实际操作，我们加深了对文件系统的理解和掌握了相关的命令和技能。 同时，我们还学习了如何使用shell来进行文件系统的操作。我们了解了shell的基本功能和用法，包括如何执行命令、如何进行文件的搜索和查找等操作。通过实际的练习，我们熟悉了在shell中的各种命令和操作技巧，提高了我们的操作效率和技术水平。 总的来说，通过本次实验，我们深入了解了Chcore操作系统中文件系统和shell的相关知识，掌握了文件系统的基本操作和shell的使用方法。这些知识和技能对我们理解和掌握操作系统的相关知识具有重要意义，也为我们今后的学习和工作打下了扎实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值