linuxpv操作
❶ 急求關於操作系統PV操作的程序代碼C或C++都可以,在線等啊!!!!!!!!!!
完整程序要花不少時間調試的，我這里給你一個實現PV操作的程序吧，5個人搶3個位子，這個你們上課應該會講的，通過幾個pv操作就可以實現，只要把我這里寫的pv操作的代碼用上就可以了。程序是在linux系統下調試的。pv操作分別對應下面的up和down（我們老師習慣用這種稱呼，於是就在代茄悉攔碼中也這么用了）
#include <stdio.h>#include <signal.h>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <sys/mman.h>#include <sys/times.h>#include <fcntl.h>#include <stdlib.h>#include <sys/sem.h> //include header file for semaphore #define FILE_SIZE 11#define NO_PROC 10 int DelayCount = 0; int readerID = 0;int writerID = 0; char* shared_buffer; int Delay100ms = 0; int* shared_buffer2;////////Variables for semaphoreoperations//陸隱///int semid;// the followings are not necessary to definehere, but just for conveniencekey_t semkey;struct sembuf operation[1];short sarray[2];int ret_val;/////////////////////////顫胡////////////////////// void init_sem(){ int*rc; //getkey semkey=ftok("/dev/null",12); if( semkey == (key_t) -1 ) { printf("main:ftok() failed\n"); exit(-1); } printf("semkeygenerated\n"); //getsemaphore set semid= semget( semkey, 2, 0666 | IPC_CREAT | IPC_EXCL ); if( semid == -1 ) { printf("main: semget()failed\n"); exit(-1); } //setthe two semaphores to 1; sarray[0]=1; sarray[1]=1; ret_val=semctl(semid,1, SETALL, sarray); if(ret_val==-1) { printf("main:semctlerror\n"); exit(-1); } printf("ddddd\n"); //setreader count rc=(int*)(&shared_buffer[FILE_SIZE]); //printf("%d\n",*shared_buffer2); *rc=0; printf("RC:%d\n",*rc);} void down(int i) //i=0, 1{ operation[0].sem_num=i; operation[0].sem_op=-1; operation[0].sem_flg=0; ret_val=semop(semid,operation,1);} void up(int i){ operation[0].sem_num=i; operation[0].sem_op=1; operation[0].sem_flg=0; ret_val=semop(semid,operation,1);}
❷ linux下創建新的PV 不能創建
如果你要將一個分區初始化成搜首塵PV，你必須首先保證這個分區沒有被使用，也就是處在離線狀態，你可以先umount /dev/sda先把這個分區卸下來然後再做PV操作芹碰。如果sda掛在你世禪的根分區下，那麼很不好意思，你已經無法將它初始化成PV了。。。。。
❸ linux 下運行C的程序，終端運行出現亂碼，該怎麼解決！！
在linux下，其實不用選擇gb2312，我都用的是utf8，當然也需要按照以上步驟進行設陸胡念置，肯定不會出現亂碼！個人喜好，大家隨意！
之前我試了很多方法，比如在/etc/sysconfig/i18n文件中改系統字體，在/etc/my.cnf中[mysqld]欄位後加入如下語句default-character-set=gb2312等等早困，我覺得沒有必要。
以上步驟看似很簡單，但是我的失敗教訓，也是我的成功心得。現在與大家分享，看後有收獲的做慎，不頂一下就是你的不厚道了！
❹ linux中什麼是ptlib
ptlib 就是指pwlib
PWLib是Portable Windows
Library的縮寫,翻譯為輕便的Windows類庫.PWLib採用C++編寫,設計初衷是為了能讓Openh323在Windows和Unix的
X-Windows下運行,
不過隨著一步步的完善PWLib已經被跨平台的程序所廣泛採用.在最新的Pandora版本中,Equivalence已經停止了PWLib中GUI部分
的開發,全面轉向了更能為Openh323所利用的PTLib,GUI部分交給了wxWindows來完成.PWLib主要功能側向網路,I/O和多線
程,主要用在高性能的可移植網路程序.
PWLib分為兩部分:基類部分和控制台部分.基類部分主要包括網路,多線程,ASN等...,所有使用PWLib的應用程序必然用到基類部分.而控制台部分則定義了一些基本的數據和設備類型,它是可選的,不過要方便移植的話還是要用到它.
下面從Hello World開始說PWLib框架:
#include //所用使用PWLib都用包含的知慶頭文件
class Hello : public PProcess //繼承主線程類PProcess
{
PCLASSINFO(Hello, PProcess) //連接PProcess的運行時函數
public:
void Main(); //主線程是從PProcess的Main()開始的
};
PCREATE_PROCESS(Hello) //定義Main()函數和初始化Hello類
void Hello::Main()
{
cout << "Hello world!\n";
}
下面詳細介紹各個類:
基本對象類:
PObject - PWLib中的根類,所有的類都派生於此
PContainer - 抽象容器類
PAbstractArray - 所有數組對象的基類
PAbstractList - 所有列表對象的基類
PAbstractDictionary - 字典對象的基類
PString - 字元類,在Openh323中隨處可見
I/O通道類
PChannel - I/O通道的基類,下面類都派生於此
PIndirectChannel - 可以交換的操作不同的I/O通道
PConsoleChannel - 進入系統命令行的通道
PPipeChannel - 在當前進程和子進程剪建立管道
PSerialChannel - 串口通信通道
PFile - 文件操作類.
PTextFile - 文本文件操作類
PStructuredFile - 結構文件操作類,不同操作文件類型都不盡相同
PFilePath -對文件的路徑描述的類
PVideoChannel - 視頻的輸入,輸出通道,採用YUV格式
PSoundChannel - 音頻的輸入,輸出通孫渣道,使用線性的PCM通道
套接字類:
PSocket - 套接字的基類,所有網路操作類派生於此
PIPSocket - IP協議層的描述類
PUDPSocket - IP協議中UDP描述類
PTCPSocket - IP協議中TCP/IP描述類
PICMPSocket - IP協議中ICMP描述類
PIPXSocket - IPX協議的基類
PEthSocket - 底層的以為網介面類,可以直接操作底層數據包
進程和線程類:
PProcess - 實現程序的主線程式控制制類
PServiceProcess - 後台程序或系統進程使用的類
PThread - 普通線程的控制類
PSemaphore - 使用搭凱握信號量的線程同步類
PMutex - 使用互斥對象的線程同步類
PCriticalSection - 使用臨界區的線程同步類
PSyncPoint - 使用事件的線程同步類
PAtomicInteger - 描述了信號量及PV操作
其他雜類:
PArgList - 命令行參數類
PConfig - 存儲應用程序的配置內容
PTime - 時間和日期的抽象類
PTimeInterval - 以毫秒為單位的記時類
PDynaLink - 動態連接類
PRemoteConnection - 網路連接控制類
PMail - 調用系統默認程序發郵件
PPluginManager - 插件管理模塊
PSmartPointer - 智能指令類
PNotifier - 通告類,可以調用任何類的任何函數
PSmartNotifierFunction - 智能的通告函數類,使用對象ID
控制台部分:
HTTP協議類:
PHTTP - HTTP協議基類
PURL - URL的具體描述
PHTML - HTML的具體描述
PHTTPServiceProcess - 後台的HTTP服務程序類
其他協議類
PInternetProtocol - Interner文本協議基類
PPOP3 - POP3協議的基類
PSMTMP - SMTP協議的基類
PFTP - FTP協議的基類
PMIMEInfo - 描述MIME信息
PTelnetSocket - 描述TELNET協議
PSocksProtocol - Socks協議的基類
PSTUNClient - 實現STUN登陸操作
PSNMP - SNMP協議的基類
PSSLChannel - 在OpenSSL基礎上建立的SSL協議類
PSASL - 在Cyrus SASL基礎上建立的SAS協議L類
PXMLRPC - 在XML和HTTP基礎上建立的XMLRPC協議描述
PSOAPClient - 實現SOAP登陸
PLDAPSession - 使用OpenLDAP進行LDAP登陸
PILSSession - 使用OpenLDAP進行ILS登陸
XMPP::Stream - 實現XMPP(Jabber)流
其他雜類:
PModem -操作Modem,使用AT命令和Modem串口通信
PIpAccessControlList - 子網掩碼的描述
PRandom - 產生隨機數類
PCypher - 不同編碼的解碼和編碼
PWAVFile - AIFF格式的WAV文件操作類
PDTMFDecoder - 對PCM流進行DTMF解碼
PMemoryFile - 讓數據存儲在內存中
PSDLVideoDevice - 使用SDL庫實現視頻設備
PXML - XML的解析器
PVXMLChannel - VXML的解析器
PTextToSpeech - 實現文本到語音的語音合成轉換
❺ LINUX 信號量共存 共享內存通信
/***Msginput.c***/
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>
#include"Mysem.h"
int main(){
FILE *fp;
int empty;
int full;
int mutex;
char * shm;
int shmid;
fp = fopen("shmid","r");
fread(&shmid,sizeof(int), 1, fp);
fread(&empty,sizeof(int), 1, fp);
fread(&full,sizeof(int), 1, fp);
fread(&mutex,sizeof(int), 1, fp);
fclose(fp);
shm = shmat(shmid, NULL, 0);
while(1){
P(&empty);
P(&mutex);
scanf("%s", shm);
if(strcmp(shm, "END") == 0){
V(&mutex);
V(&full);
break;
}
V(&mutex);
V(&full);
}
return 0;
}
/****Mysem.c*****/
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>
#include "Mysem.h"
#define BUFFER_SIZE 512
int main(){
char *shm;
int empty;
int full;
int mutex;
int shmid;
int pid;
int i;
FILE *fp;
// int init_sem_value = 0;
empty = semget(IPC_PRIVATE, 1, (0600|IPC_CREAT));
if(empty == -1){
perror("semget");
exit(1);
}
if(semctl(empty, 0, SETVAL, 1)<0){
perror("semctl");
exit(1);
}
full = semget(IPC_PRIVATE, 1, (0600|IPC_CREAT));
if(full == -1){
perror("semget");
exit(1);
}
if(semctl(full, 0, SETVAL, 0)<0){
perror("semctl");
exit(1);
}
mutex = semget(IPC_PRIVATE, 1, (0600|IPC_CREAT));
if(mutex == -1){
perror("semget");
exit(1);
}
if(semctl(mutex, 0, SETVAL, 1)<0){
perror("semctl");
exit(1);
}
shmid = shmget(IPC_PRIVATE, (BUFFER_SIZE*sizeof(char)),(IPC_CREAT|0600));
if(shmid == -1){
perror("shmget");
exit(1);
}
shm = shmat(shmid, NULL, 0);
if(shm == (char*)-1){
perror("shmat");
exit(1);
}
fp = fopen("shmid","w");
fwrite(&shmid, sizeof(int), 1, fp);
fwrite(&empty, sizeof(int), 1, fp);
fwrite(&full, sizeof(int), 1, fp);
fwrite(&mutex, sizeof(int), 1, fp);
fclose(fp);
pid = fork();
if(pid == 0){
execlp("./Msginput", "./Msginput",0);
perror("execlp");
exit(1);
}else{
while(1){
P(&full);
P(&mutex);
printf("%s\n", shm);
if(strcmp(shm,"END") == 0){
V(&mutex);
V(&empty);
break;
}
V(&mutex);
V(&empty);
}
}
wait(0);
if(semctl(full, 0, IPC_RMID, 1) == -1){
perror("semctl");
exit(1);
}
if(semctl(empty, 0, IPC_RMID, 1) == -1){
perror("semctl");
exit(1);
}
if(semctl(mutex, 0, IPC_RMID, 1) == -1){
perror("semctl");
exit(1);
}
if(shmctl(shmid, IPC_RMID, NULL) == -1){
perror("shmctl");
exit(1);
}
exit(0);
}
/****Mysem.h*****/
void P(int *s);
void V(int *s);
extern void *shmat (int __shmid, __const void *__shmaddr, int __shmflg);
void P(int *s){
struct sembuf sembuffer, *sops;
sops=&sembuffer;
sops->sem_num = 0;
sops->sem_op = -1;
sops->sem_flg = 0;
if(semop(*s, sops, 1)<0){
perror("semop");
exit(1);
}
return ;
}
void V(int *s){
struct sembuf sembuffer, *sops;
sops = &sembuffer;
sops->sem_num = 0;
sops->sem_op = 1;
sops->sem_flg = 0;
if(semop(*s, sops, 1)<0){
perror("semop");
exit(1);
}
return;
}
❻ linux中pv操作偽代碼怎麼寫
//演算法描述語言使用基於C語言的偽代碼
//演算法思想：根據樓主的要求「為防止數的丟失和重復取同一個數」可以看出，進程A、進程B、進程C三者之間應該是互斥的關系。那麼問題所限定的使用帶埋信號量的方式來管理的潛藏意思，就是要利用PV
原語實現並發進程在資源爭奪中拆薯有效互斥。
//而具體實現的目標是「防止數旅行者的丟失」和「重復取同一個數」。由於本人不才，只討論單任務系統下的狀況。
//「數的丟失」的情況主要是進程A產生了隨即變數給F後，但在進程B或者進程C處理之前又獲得處理機的使用權而覆蓋了之前那個未被處理過的F中的數——進程A連續獲得處理機的使用權，而進程B、進
❼ LINUX高手進！有關於PV操作的問題！
什麼意思？求PV元語具體實現程序？
❽ 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函數用於喚醒一個等待目標條件變數線程.但有時候我們可能需要喚醒一個固定的線程,可以通過間接的方法實現:定義一個能夠唯一標識目標線程的全局變數,在喚醒等待條件變數的線程前先設置該變數為目標線程,然後採用廣播的方式喚醒所有等待的線程,這些線程被喚醒之後都檢查該變數以判斷是否是自己.
採用條件變數+互斥鎖實現生產者消費者模型:
運行結果:
阻塞隊列+生產者消費者
運行結果:
❾ 操作系統的pv操作是編程用的嗎百度了很多，請大佬們用通俗的話講一下，請不要復制粘貼，謝謝。
PV操作是信號量的一種，主要是用在生產者-消費者關系模型里，解決線程/進程並發和資源沖突的問題。在操作系統層面會提供相關的API用於信號量操作，如Windows C和Linux C下都有對應的信號量操作函數。某些編程語言如Java本身也提供信號量等並發機制，它也是依靠操作系統底層的這些API實現的。
❿ 求助，關於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 根筷子的互斥訪問。
示例代碼：