linux生產者

Ⅰ 在linux下編一個C或C++程序，實現多個生產者與多個消費者通過緩沖區或管道通信。

http://..com/question/328567176.html#here
這里是一個很好的例子。我正在為那個提問者分析，你可以借鑒。

Ⅱ 求教Linux下gcc編譯生產者消費者問題 #include <stdio.h> gcc編譯時出錯 錯誤如下圖

報錯是因為你使用的函數沒有聲明，缺少頭文件，所以加上頭文件就ok了
包含頭文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Ⅲ 編程牛人，江湖救急 在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的線程同步問題

【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 根筷子的互斥訪問。
示例代碼：

Ⅳ kafka在linux下面創建主題testlog成功了，但隨後創建生產者卻沒有成

開2個shell窗口，一個消息生產者，一個消息消費者，生產者發送消息，消費者接收消息

Ⅵ Linux 多線程編程(二)2019-08-10

三種專門用於線程同步的機制:POSIX信號量,互斥量和條件變數.

在Linux上信號量API有兩組,一組是System V IPC信號量,即PV操作,另外就是POSIX信號量,POSIX信號量的名字都是以sem_開頭.

phshared參數指定信號量的類型,若其值為0,就表示這個信號量是當前進程的局部信號量,否則該信號量可以在多個進程之間共享.value值指定信號量的初始值,一般與下面的sem_wait函數相對應.

其中比較重要的函數sem_wait函數會以原子操作的方式將信號量的值減一,如果信號量的值為零,則sem_wait將會阻塞,信號量的值可以在sem_init函數中的value初始化;sem_trywait函數是sem_wait的非阻塞版本;sem_post函數將以原子的操作對信號量加一,當信號量的值大於0時,其他正在調用sem_wait等待信號量的線程將被喚醒.
這些函數成功時返回0,失敗則返回-1並設置errno.

生產者消費者模型:
生產者對應一個信號量:sem_t procer;
消費者對應一個信號量:sem_t customer;
sem_init(&procer,2)----生產者擁有資源,可以工作;
sem_init(&customer,0)----消費者沒有資源,阻塞;

在訪問公共資源前對互斥量設置（加鎖），確保同一時間只有一個線程訪問數據，在訪問完成後再釋放（解鎖）互斥量.
互斥鎖的運行方式:串列訪問共享資源;
信號量的運行方式:並行訪問共享資源;
互斥量用pthread_mutex_t數據類型表示，在使用互斥量之前，必須使用pthread_mutex_init函數對它進行初始化，注意，使用完畢後需調用pthread_mutex_destroy.

pthread_mutex_init用於初始化互斥鎖，mutexattr用於指定互斥鎖的屬性，若為NULL，則表示默認屬性。除了用這個函數初始化互斥所外，還可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER。
pthread_mutex_destroy用於銷毀互斥鎖，以釋放佔用的內核資源，銷毀一個已經加鎖的互斥鎖將導致不可預期的後果。

pthread_mutex_lock以原子操作給一個互斥鎖加鎖。如果目標互斥鎖已經被加鎖，則pthread_mutex_lock則被阻塞，直到該互斥鎖佔有者把它給解鎖.
pthread_mutex_trylock和pthread_mutex_lock類似，不過它始終立即返回，而不論被操作的互斥鎖是否加鎖，是pthread_mutex_lock的非阻塞版本.當目標互斥鎖未被加鎖時，pthread_mutex_trylock進行加鎖操作；否則將返回EBUSY錯誤碼。注意：這里討論的pthread_mutex_lock和pthread_mutex_trylock是針對普通鎖而言的，對於其他類型的鎖，這兩個加鎖函數會有不同的行為.
pthread_mutex_unlock以原子操作方式給一個互斥鎖進行解鎖操作。如果此時有其他線程正在等待這個互斥鎖，則這些線程中的一個將獲得它.

三個列印機輪流列印:

輸出結果:

如果說互斥鎖是用於同步線程對共享數據的訪問的話,那麼條件變數就是用於在線程之間同步共享數據的值.條件變數提供了一種線程之間通信的機制:當某個共享數據達到某個值時,喚醒等待這個共享數據的線程.
條件變數會在條件不滿足的情況下阻塞線程.且條件變數和互斥量一起使用，允許線程以無競爭的方式等待特定的條件發生.

其中pthread_cond_broadcast函數以廣播的形式喚醒所有等待目標條件變數的線程,pthread_cond_signal函數用於喚醒一個等待目標條件變數線程.但有時候我們可能需要喚醒一個固定的線程,可以通過間接的方法實現:定義一個能夠唯一標識目標線程的全局變數,在喚醒等待條件變數的線程前先設置該變數為目標線程,然後採用廣播的方式喚醒所有等待的線程,這些線程被喚醒之後都檢查該變數以判斷是否是自己.

採用條件變數+互斥鎖實現生產者消費者模型:

運行結果:

阻塞隊列+生產者消費者

運行結果:

Ⅶ 在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下生產者與消費者問題的完整程序

是啊，在多處理器中線程是可以並行執行的，在單處理器中線程是並發執行的啊，所謂並行執行就是同時執行的啊，並發執行就是簡單的說一個一個執行的，由於處理器的速度快，就像一起執行是的，就是並發執行。這兩個線程一起運行，就看上面的情況了。如果不明白建議那本操作系統的書看看，或者在網上找進程和線程的網路讀。

Ⅸ 在LINUX下,用QT實現生產者與消費者關系的實例

定義一個QList鏈表，
生產者不斷地將數據添加到QList的隊尾，
消費者不斷去詢問QList是否為空，如為空則等待，否則就獲取QList隊頭第一個數據。
如此就是一個簡單的生產者與消費者關系
如果要完善一下，則需要添加一個信號量來管理QList的刪除和添加操作，防止出現錯誤