linux消费者问题
㈠ 操作系统课程设计，生产者-消费者问题的模拟实现，要求在linux下实现
操作系统设计，生产者-消费者问题的模拟实现，要求在linux下实现保留完整 源文件.
㈡ 编程牛人，江湖救急 在linux下用c语言编程实现生产者-消费者问题。
超级简单的，写自己的N皇后：
＃包括
诠释Q [20];
诠释计数= 0;
无效打印（诠释n）
{;
计数+ +;
为（i = 1; <=我+ +）
{printf（“请（％d个， ％D）“，I，Q []）;
}
printf的（”\ n“）;
}
诠释广场（INT I，K） /> {;
J = 1;
（J <K）
{如果（（Q [J] == I）| | ABS（Q [J]-I ）== ABS（JK））返回0;
J + +;
}
返回1;
}
无效皇后（K，诠释n） BR /> {;
（K> N）
（N）;
其他
{为（i = 1; <= n; i + + ）
（地点（I，K）== 1）
【q [K] = I;
皇后（K +1，N）;
} }
}
廉政的main（）
{N;
scanf的（“％D”，＆N）;
皇后区（1，N）; BR />参考getch（）;
返回0;
}
㈢ 在linux下用c语言实现用多进程同步方法演示“生产者-消费者”问题
这个问题需要的知识主要包括：
1 多进程间进行通信；
2 使用同步信号量（semaphore）和互斥信号量（mutex）进行数据保护。
参考代码如下，可以参照注释辅助理解：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#defineN2//消费者或者生产者的数目
#defineM10//缓冲数目
intin=0;//生产者放置产品的位置
intout=0;//消费者取产品的位置
intbuff[M]={0};//缓冲初始化为0，开始时没有产品
sem_tempty_sem;//同步信号量，当满了时阻止生产者放产品
sem_tfull_sem;//同步信号量，当没产品时阻止消费者消费
pthread_mutex_tmutex;//互斥信号量，一次只有一个线程访问缓冲
intproct_id=0;//生产者id
intprochase_id=0;//消费者id
/*打印缓冲情况*/
voidprint()
{
inti;
for(i=0;i<M;i++)
printf("%d",buff[i]);
printf(" ");
}
/*生产者方法*/
void*proct()
{
intid=++proct_id;
while(1)
{
//用sleep的数量可以调节生产和消费的速度，便于观察
sleep(1);
//sleep(1);
sem_wait(&empty_sem);
pthread_mutex_lock(&mutex);
in=in%M;
printf("proct%din%d.like: ",id,in);
buff[in]=1;
print();
++in;
pthread_mutex_unlock(&mutex);
sem_post(&full_sem);
}
}
/*消费者方法*/
void*prochase()
{
intid=++prochase_id;
while(1)
{
//用sleep的数量可以调节生产和消费的速度，便于观察
sleep(1);
//sleep(1);
sem_wait(&full_sem);
pthread_mutex_lock(&mutex);
out=out%M;
printf("prochase%din%d.like: ",id,out);
buff[out]=0;
print();
++out;
pthread_mutex_unlock(&mutex);
sem_post(&empty_sem);
}
}
intmain()
{
pthread_tid1[N];
pthread_tid2[N];
inti;
intret[N];
//初始化同步信号量
intini1=sem_init(&empty_sem,0,M);
intini2=sem_init(&full_sem,0,0);
if(ini1&&ini2!=0)
{
printf("seminitfailed ");
exit(1);
}
//初始化互斥信号量
intini3=pthread_mutex_init(&mutex,NULL);
if(ini3!=0)
{
printf("mutexinitfailed ");
exit(1);
}
//创建N个生产者线程
for(i=0;i<N;i++)
{
ret[i]=pthread_create(&id1[i],NULL,proct,(void*)(&i));
if(ret[i]!=0)
{
printf("proct%dcreationfailed ",i);
exit(1);
}
}
//创建N个消费者线程
for(i=0;i<N;i++)
{
ret[i]=pthread_create(&id2[i],NULL,prochase,NULL);
if(ret[i]!=0)
{
printf("prochase%dcreationfailed ",i);
exit(1);
}
}
//销毁线程
for(i=0;i<N;i++)
{
pthread_join(id1[i],NULL);
pthread_join(id2[i],NULL);
}
exit(0);
}
在Linux下编译的时候，要在编译命令中加入选项-lpthread以包含多线程支持。比如存储的C文件为demo.c,要生成的可执行文件为demo。可以使用命令：
gcc demo.c -o demo -lpthread
程序中为便于观察，使用了sleep(1);来暂停运行，所以查看输出的时候可以看到，输出是每秒打印一次的。
㈣ 求教Linux下gcc编译生产者消费者问题 #include <stdio.h> gcc编译时出错 错误如下图
报错是因为你使用的函数没有声明，缺少头文件，所以加上头文件就ok了
包含头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
㈤ 求一个linux下生产者与消费者问题的完整程序
是啊，在多处理器中线程是可以并行执行的，在单处理器中线程是并发执行的啊，所谓并行执行就是同时执行的啊，并发执行就是简单的说一个一个执行的，由于处理器的速度快，就像一起执行是的，就是并发执行。这两个线程一起运行，就看上面的情况了。如果不明白建议那本操作系统的书看看，或者在网上找进程和线程的网络读。
㈥ linux下用多线程同步方法解决生产者－消费者问题
...........
你去搜下吧，这种是OS的经典题目，网上多的是源码。。。。
㈦ C语言编写生产消费者问题(Linux下用信号量)各位大神，急求呀~~~~~~
多长时间是你自己定的啊。如果生产时间和消费时间相等那么里面一直是空的，60/0.1不就是生产了多少个嘛。但是实际上他们一般都是不相等的。
㈧ 求教Linux下gcc编译生产者消费者问题 gcc编译时出错 错误如下
这个是C++程序，因此你需要安装g++编译器才行
安装：sudo apt-get install g++
编译：g++ shi.cpp -o hello就会编译一个hello的可执行文件~~~
㈨ 求助，关于linux的线程同步问题
【Linux多线程】三个经典同步问题
标签： 多线程同步生产者与消费者写者与读者
目录(?)[+]
在了解了《同步与互斥的区别 》之后，我们来看看几个经典的线程同步的例子。相信通过具体场景可以让我们学会分析和解决这类线程同步的问题，以便以后应用在实际的项目中。
一、生产者-消费者问题
问题描述：
一组生产者进程和一组消费者进程共享一个初始为空、大小为 n 的缓冲区，只有缓冲区没满时，生产者才能把消息放入到缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从中取出消息，否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或者一个消费者从中取出消息。
分析：
关系分析：生产者和消费者对缓冲区互斥访问是互斥关系，同时生产者和消费者又是一个相互协作的关系，只有生产者生产之后，消费者才能消费，它们也是同步关系。
整理思路：这里比较简单，只有生产者和消费者两个进程，且这两个进程存在着互斥关系和同步关系。那么需要解决的是互斥和同步的PV操作的位置。
信号量设置：信号量mutex作为互斥信号量，用于控制互斥访问缓冲池，初值为1；信号量full用于记录当前缓冲池中“满”缓冲区数，初值为 0；信号量empty用于记录当前缓冲池中“空”缓冲区数，初值为n。
代码示例：（semaphore类的封装见下文）
#include<iostream>
#include<unistd.h> // sleep
#include<pthread.h>
#include"semaphore.h"
using namespace std;
#define N 5
semaphore mutex("/", 1); // 临界区互斥信号量
semaphore empty("/home", N); // 记录空缓冲区数，初值为N
semaphore full("/home/songlee",0); // 记录满缓冲区数，初值为0
int buffer[N]; // 缓冲区，大小为N
int i=0;
int j=0;
void* procer(void* arg)
{
empty.P(); // empty减1
mutex.P();
buffer[i] = 10 + rand() % 90;
printf("Procer %d write Buffer[%d]: %d\n",arg,i+1,buffer[i]);
i = (i+1) % N;
mutex.V();
full.V(); // full加1
}
void* consumer(void* arg)
{
full.P(); // full减1
mutex.P();
printf(" \033[1;31m");
printf("Consumer %d read Buffer[%d]: %d\n",arg,j+1,buffer[j]);
printf("\033[0m");
j = (j+1) % N;
mutex.V();
empty.V(); // empty加1
}
int main()
{
pthread_t id[10];
// 开10个生产者线程，10个消费者线程
for(int k=0; k<10; ++k)
pthread_create(&id[k], NULL, procer, (void*)(k+1));
for(int k=0; k<10; ++k)
pthread_create(&id[k], NULL, consumer, (void*)(k+1));
sleep(1);
return 0;
}
编译运行输出结果：
Procer 1 write Buffer[1]: 83
Procer 2 write Buffer[2]: 26
Procer 3 write Buffer[3]: 37
Procer 5 write Buffer[4]: 35
Procer 4 write Buffer[5]: 33
Consumer 1 read Buffer[1]: 83
Procer 6 write Buffer[1]: 35
Consumer 2 read Buffer[2]: 26
Consumer 3 read Buffer[3]: 37
Consumer 4 read Buffer[4]: 35
Consumer 5 read Buffer[5]: 33
Consumer 6 read Buffer[1]: 35
Procer 7 write Buffer[2]: 56
Procer 8 write Buffer[3]: 22
Procer 10 write Buffer[4]: 79
Consumer 9 read Buffer[2]: 56
Consumer 10 read Buffer[3]: 22
Procer 9 write Buffer[5]: 11
Consumer 7 read Buffer[4]: 79
Consumer 8 read Buffer[5]:
二、读者-写者问题
问题描述：
有读者和写者两组并发线程，共享一个文件，当两个或以上的读线程同时访问共享数据时不会产生副作用，但若某个写线程和其他线程（读线程或写线程）同时访问共享数据时则可能导致数据不一致的错误。因此要求：
允许多个读者可以同时对文件执行读操作；
只允许一个写者往文件中写信息；
任一写者在完成写操作之前不允许其他读者或写者工作；
写者执行写操作前，应让已有的读者和写者全部退出。
分析：
关系分析：由题目分析可知，读者和写者是互斥的，写者和写者也是互斥的，而读者和读者不存在互斥问题。
整理思路：写者是比较简单的，它与任何线程互斥，用互斥信号量的 PV 操作即可解决。读者的问题比较复杂，它必须实现与写者的互斥，多个读者还可以同时读。所以，在这里用到了一个计数器，用它来判断当前是否有读者读文件。当有读者的时候写者是无法写文件的，此时读者会一直占用文件，当没有读者的时候写者才可以写文件。同时，不同的读者对计数器的访问也应该是互斥的。
信号量设置：首先设置一个计数器count，用来记录当前的读者数量，初值为0；设置互斥信号量mutex，用于保护更新 count 变量时的互斥；设置互斥信号量rw用于保证读者和写者的互斥访问。
代码示例：
#include<iostream>
#include<unistd.h> // sleep
#include<pthread.h>
#include"semaphore.h"
using namespace std;
int count = 0; // 记录当前的读者数量
semaphore mutex("/",1); // 用于保护更新count变量时的互斥
semaphore rw("/home",1); // 用于保证读者和写者的互斥
void* writer(void* arg)
{
rw.P(); // 互斥访问共享文件
printf(" Writer %d start writing...\n", arg);
sleep(1);
printf(" Writer %d finish writing...\n", arg);
rw.V(); // 释放共享文件
}
void* reader(void* arg)
{
mutex.P(); // 互斥访问count变量
if(count == 0) // 当第一个读线程读文件时
rw.P(); // 阻止写线程写
++count; // 读者计数器加1
mutex.V(); // 释放count变量
printf("Reader %d start reading...\n", arg);
sleep(1);
printf("Reader %d finish reading...\n", arg);
mutex.P(); // 互斥访问count变量
--count; // 读者计数器减1
if(count == 0) // 当最后一个读线程读完文件
rw.V(); // 允许写线程写
mutex.V(); // 释放count变量
}
int main()
{
pthread_t id[8]; // 开6个读线程，2个写线程
pthread_create(&id[0], NULL, reader, (void*)1);
pthread_create(&id[1], NULL, reader, (void*)2);
pthread_create(&id[2], NULL, writer, (void*)1);
pthread_create(&id[3], NULL, writer, (void*)2);
pthread_create(&id[4], NULL, reader, (void*)3);
pthread_create(&id[5], NULL ,reader, (void*)4);
sleep(2);
pthread_create(&id[6], NULL, reader, (void*)5);
pthread_create(&id[7], NULL ,reader, (void*)6);
sleep(4);
return 0;
}555657585960
编译运行的结果如下：
Reader 2 start reading...
Reader 1 start reading...
Reader 3 start reading...
Reader 4 start reading...
Reader 1 finish reading...
Reader 2 finish reading...
Reader 3 finish reading...
Reader 4 finish reading...
Writer 1 start writing...
Writer 1 finish writing...
Writer 2 start writing...
Writer 2 finish writing...
Reader 5 start reading...
Reader 6 start reading...
Reader 5 finish reading...
Reader 6 finish reading...
三、哲学家进餐问题
问题描述：
一张圆桌上坐着 5 名哲学家，桌子上每两个哲学家之间摆了一根筷子，桌子的中间是一碗米饭，如图所示：
哲学家们倾注毕生精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿的时候，才试图拿起左、右两根筷子（一根一根拿起）。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿到了两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。
分析：
关系分析：5名哲学家与左右邻居对其中间筷子的访问是互斥关系。
整理思路：显然这里有 5 个线程，那么要如何让一个哲学家拿到左右两个筷子而不造成死锁或饥饿现象？解决方法有两个，一个是让他们同时拿两个筷子；二是对每个哲学家的动作制定规则，避免饥饿或死锁现象的发生。
信号量设置：定义互斥信号量数组chopstick[5] = {1,1,1,1,1}用于对 5 根筷子的互斥访问。
示例代码：
㈩ 在linux下,处理生产者消费者问题时,生产者完全可以在完成生产任务之后退出,但为什么一旦退出就会死机
display(Buffer);
tail++;
count++;
cout<<"按ENTER继续...."<<endl;
ch=getchar();
ReleaseMutex(hMutex); //结束临界区
PulseEvent(hNotEmptyEvent); //唤醒消费者线程
}
}
}
}
//////////////////////////////////////////////////////////////////
//p2