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