#include "WINDOWS.H"
の#include <conio.h>
書式#include <stdlib.h>に含ま
する#include <io.h>
の#include <文字列>
の#include <conio.h>
書式#include <fstreamの>
名前空間stdを使用。
#define READER 'R' //読者
の#define WRITER 'W' //ライター
の#define INTE_PER_SEC 1000 //クロック秒あたりの割り込みの数
の#define MAX_THREAD_NUMは、スレッドの64 //最大数は
MAX_FILE_NUM 32のデータファイルの//最大数を#defineし
＃ MAX_STR_LEN 32 //文字列の長さを定義します
int型readcount = 0;
int型writecount = 0;
CRITICAL_SECTIONのRP_Write; //クリティカル領域
CRITICAL_SECTION cs_Write;
CRITICAL_SECTION cs_Read;
ThreadInfoにストラクト{
int型のシリアル; //スレッドIDの
文字エンティティ; //スレッド型（リーダライタのスレッドまたはスレッドの分析）
ダブル遅延;
ダブル持続;
};
//リーダ優先-リーダースレッド
// P：読者のスレッド情報
空隙RP_ReaderThread（ボイド* P）{
//互斥变量
HANDLE h_Mutex。
h_Mutex = OpenMutex（MUTEX_ALL_ACCESS、FALSE、 "mutex_for_readcount"）。
DWORD wait_for_mutex; //ミューテックス変数の所有権を待っている
DWORDのm_delay; //遅延
DWORDのm_persist; //読み取り、ファイル期間
m_serialのint;スレッドの//数;
//パラメータから情報を取得
m_serial =（（ThreadInfoに*）（ P ）） - >シリアル;
m_delay =（DWORD）（（（ThreadInfoに*）（P）） - >ディレイ* INTE_PER_SEC）;
m_persist =（DWORD）（（（ThreadInfoに*）（P）） - >）* INTE_PER_SEC存続。
スリープ（m_delay）; //遅延待ち
printf（ "Readerのスレッド％d個のsentsは読み取りが必要とする\ n"、m_serial）。
//ミューテックス待ちがReadCountへのアクセスを確保するために、修正ミューテックス
wait_for_mutex =のWaitForSingleObject（h_Mutex、-1）;
読者の//数が増加
; ++ ReadCountを
IF（ReadCount == 1）{
//最初のリーダーを、リソースを待っています
EnterCriticalSection（＆RP_Write）;
}
ReleaseMutex（h_Mutex）; //解放ミューテックス
//読み込みファイル
のprintf（、m_serial "％d個の読者は\ N-を読み始めた"）;
スリープ（m_persist）で。
//スレッド出口
のprintf（ "％dのリーダーが\ N-を完了しました。"、M_serial）;
//待機ミューテックス排他的変更、readcountへのアクセスを確保するため
wait_for_mutex =のWaitForSingleObject（h_Mutex、-1）;
読者の//数還元
readcount--;
IFを（ReadCount == 0）{
//すべての読者が読んでいる場合、ウェイクライタ
LeaveCriticalSection（＆RP_Write）;
}
ReleaseMutex（h_Mutex）; //解放ミューテックス
}
//リーダ優先-ライタースレッド
// P：ライタースレッド情報
ボイドRP_WriterThread（P-ボイド*）{
DWORDのm_delay; //遅延
DWORDのm_persist; //書き込みファイル期間
INT m_serial、スレッドの数//
//パラメータ情報から得られた
;>シリアル- m_serial =（（ThreadInfoに*）（P））
m_delay =（DWORD）（（（ThreadInfoに*）（P）） - >ディレイ* INTE_PER_SEC）;
m_persist =（DWORD）（（（ * ThreadInfoに）（P-））の- >）* INTE_PER_SEC存続;
でスリープ（m_delay）; //遅延待っている
のprintf（）、m_serial; "待機中の作家％D \ N-"
//待機リソース
EnterCriticalSection（＆RP_Write）。
//書き込みファイル
のprintf（ "％d個の作家は\ N-を書き始めました。"、M_serial）;
スリープ（m_persist）で。
//スレッド出口
のprintf（ "％d個のライターが\ N-を完了しました。"、M_serial）;
//解放資源
LeaveCriticalSection（＆RP_Write）;
}
//読者優先度ハンドラ
//ファイル：ファイル名
のボイドReaderPriority（のconstのchar *ファイル）{
DWORD n_thread = 0; //スレッド数
DWORD THREAD_ID; //はID継続
DWORDがwait_for_all; //すべてのスレッドの終わりのための待ち時間が
//ミューテックスオブジェクト
HANDLE h_Mutex;
h_Mutex CreateMutex =（NULL、FALSE、 "mutex_for_readcount"）。
//は、オブジェクトの配列に進み
、HANDLE h_Thread [MAX_THREAD_NUM]
ThreadInfoにthread_info [MAX_THREAD_NUM]。
readcount = 0; //初期化ReadCount
InitializeCriticalSection（＆RP_Write）; //クリティカルセクションの初期化
はifstream INFILEを、
inFile.open（ファイル）; //ファイルを開く
のprintf（ "リーダー：\ \ N- N-"）;
しばらく（INFILE）{
//すべての読者を読んで、書き込み情報
INFILE thread_info >> [n_thread] .serial;
INFILE thread_info >> [n_thread] .entity;
INFILE thread_info >> [n_thread] .delay;
。INFILE thread_info >> [n_thread ++]持続;
inFile.getを（）;
}
ため（INT iは= 0; I <（INT）（n_thread）; I ++）{
IF（[I] .entity == READER || thread_info thread_info [I] .entity == 'R'）{
h_Thread [I] =のCreateThread（NULL、0、（LPTHREAD_START_ROUTINE）（RP_ReaderThread）、＆thread_info [i]は、0、＆THREAD_ID）。//创建读者线程
}
そうであれば（thread_info [I] .entity == WRITER || thread_info [I] .entity == 'W'）{
//创建写者线程
h_Thread [I] =のCreateThread（NULL、0、 （LPTHREAD_START_ROUTINE）（RP_WriterThread）、＆thread_info [i]は、0、＆THREAD_ID）。
}
}
すべてのスレッドの//待機が終了
wait_for_all =たWaitForMultipleObjects（n_thread、h_Thread、TRUEを、-1）;
のprintfは（ "すべてのリーダーとライターは\ N-を完了しました。"）;
}
//プラスを書く- Readerが処理
// P：読者のスレッド情報
のボイドWP_ReaderThread（void *型のp）{
//互斥变量
HANDLEのh_Mutex1。
h_Mutex1 = OpenMutex（MUTEX_ALL_ACCESS、FALSE、 "mutex1"）。
HANDLEのh_Mutex2。
h_Mutex2 = OpenMutex（MUTEX_ALL_ACCESS、FALSE、 "mutex2"）。
DWORD wait_for_mutex1; //ミューテックス変数の所有権を待っている
DWORDのwait_for_mutex2;
DWORDのm_delay; //遅延
DWORDのm_persist; //このファイル期間
m_serialのint;スレッドの//数
//パラメータから情報を取得する
m_serial =（（ThreadInfoに*） （P）） - >シリアル;
m_delay =（DWORD）（（（ThreadInfoに*）（P）） - >ディレイ* INTE_PER_SEC）;
m_persist =（DWORD）（（（ThreadInfoに*）（P）） - >持続* INTE_PER_SEC ）;
//遅延待機、スリープ（m_delay）で
printf（ "％d個の読者は\ N-を待っている。"、m_serial）;
wait_for_mutex1 =のWaitForSingleObject（h_Mutex1、-1）;
//クリティカルセクションリーダー入る
EnterCriticalSection（＆cs_Readを）;
//ブロックミューテックスmutex2、readcountへのアクセスを確保するために排他的変更
wait_for_mutex2を=のWaitForSingleObject（h_Mutex2、-1）;
//変更読者
ReadCount ++;
IF（ReadCount == 1）{
//最初のリーダー、仕上げ用ライターを待つ場合
EnterCriticalSection（＆cs_Write）;
}
ReleaseMutexは（h_Mutex2）; //リリースミューテックスmutex2
//他の読者は、クリティカルセクション入力することができ
LeaveCriticalSection（＆cs_Writeを）;
ReleaseMutex（h_Mutex1）;
//読み込みファイル
のprintf（ "％d個の読者は\ N-を読み始めた。"、m_serial）;
睡眠時（m_persist）;
//出口スレッド
のprintf（ "％dのリーダーが\ N-を完了しました。"、m_serial）;
//ブロッキングミューテックスmutex2、readcountへのアクセスを確保するため、修正相互に排他的
=のWaitForSingleObjectのwait_for_mutex2（h_Mutex2、-1）;
readcount--;
IF（ReadCount == 0）{
//最後リーダ、ライタウェークアップ
LeaveCriticalSection（＆cs_Write）;
}
ReleaseMutex（h_Mutex2）; //解放ミューテックス
}
//プラスの書き込み-書き込みスレッド
// P：ライター・スレッド情報
のボイドWP_WriteThread（P-無効*）{
DWORDのm_delay; //遅延
DWORDのm_persist; //書き込みファイルのデュレーション
int型m_serial; //スレッド番号
DWORD wait_for_mutex3;
//ミューテックス
HANDLEのh_Mutex3;
h_Mutex3 = OpenMutex（MUTEX_ALL_ACCESS、FALSE、 "mutex3"）。
//パラメータから情報を取得
m_serial =（（ThreadInfoに*）（P）） - >シリアル;
m_delay =（DWORD）（（（ThreadInfoに*）（P）） - > *ディレイINTE_PER_SEC）;
m_persist =（DWORD）（ （（ThreadInfoに*）（P-）の） - >）* INTE_PER_SEC持続し、
スリープ時（m_delay）; //遅延待っている
のprintf（、m_serial）; "ライターを待ち％D \ nが。"
//ミューテックスはwritecountへのアクセスを確保するために、mutex3を遮断、修飾ミューテックス
; wait_for_mutex3 =のWaitForSingleObject（h_Mutex3、-1）
++ writecount;読者の//数は修正
IF {（writecount == 1）
//最初の作家、読者が読むのを待っ
EnterCriticalSection（＆cs_Readを）;
}
ReleaseMutex（h_Mutex3）。
//クリティカルセクションライター入る
EnterCriticalSection（＆cs_Writeを）;
//書き込みファイル
のprintf（、m_serial "作家は\％D N-を書き始めました。"）;
でスリープ（m_persist）;
//終了スレッド
のprintf（「％dがライターとなっています完全な）\、「N- m_serial;
//は、クリティカル領域のまま
LeaveCriticalSection（＆cs_Writeを）。
//ミューテックスは修正ミューテックス、writercountへのアクセスを確保するために、mutex3ブロッキング
wait_for_mutex3 =のWaitForSingleObject（h_Mutex3、-1）;
writecount--;読者の//数は修正
IF（writecount == 0）{
//ライターの完成を、読者が読むことができる
LeaveCriticalSection（＆cs_Readを）;
}
ReleaseMutex（h_Mutex3）;
}
//書き込み好適ハンドラ
//ファイル：ファイル名
のボイドWriterPriority（のconstのchar *ファイル）{
DWORD n_thread = 0; //スレッドの数
DWORD THREAD_ID; //スレッドID
DWORDがwait_for_all、すべてのスレッドの終了を待つ//
相互//撥オブジェクト
HANDLEのh_Mutex1;
h_Mutex1 = CreateMutex（NULL、FALSE、 "mutex1"）;
HANDLEのh_Mutex2;
h_Mutex2 = CreateMutex（NULL、FALSE、 "mutex2"）;
HANDLEのh_Mutex3;
h_Mutex3 = CreateMutex（NULL、FALSE、 "mutex3"）。
//线程对象
HANDLE h_Thread [MAX_THREAD_NUM]。
thread_info ThreadInfoに【MAX_THREAD_NUM]。
readcount = 0; //初期化ReadCount
writecount = 0; //初期化writecount
InitializeCriticalSection（＆cs_Write）; //クリティカルセクションの初期化
InitializeCriticalSection（＆cs_Read）;
はifstream INFILE;
inFile.open（ファイル）; //ファイルを開く
のprintf（「ライタースレッド：\ N- \ N- "）;
一方（INFILE）{
INFILE thread_info >> [n_thread] .serial;
INFILE thread_info >> [n_thread] .entity;
INFILE thread_info >> [n_thread] .delay;
INFILE thread_info >> [n_thread ++ ] .persist;
inFile.get（）;
}
のための（INT I = 0; I <（INT）（n_thread）; I ++）{
IF（thread_info [I] == READER || .entity thread_info [I] = .entity = 'R'）{
//リーダースレッドを作成
h_Thread [I] =のCreateThread（NULL、0、（LPTHREAD_START_ROUTINE）（RP_ReaderThread）、＆thread_info [i]は、0、＆THREAD_ID）。
}
他IF（[I] == WRITER || .entity thread_info thread_info [I] .entity == 'Wは'）{
//により書き込みプロセスを作成
h_Thread [I] =のCreateThread（NULL 、0、（LPTHREAD_START_ROUTINE）（RP_WriterThread ）、および[I]、0、＆なthread_id）thread_info;
}
}
//待機すべてのスレッドのを終了
; wait_for_all =たWaitForMultipleObjects（n_thread、h_Thread、TRUE、-1）
のprintf（ "すべてのリーダとライタが完了している\ N-"） ;
}
//メイン関数
INTメイン（INT ARGC、CHAR * ARGV []）{
チャーCH;
（真の）一方{
のprintf（「************************************************************ *************** \ N- "）;
のprintf（" 1読者のスレッド\ N- "）;
のprintf（" 2.ライタースレッド\ N- "）;
のprintf（" 3。終了スレッド\ N- "）;
のprintf（" ************************************* \「N- ）;
のprintf（ "入力：または1,2- 3："）;
//入力された情報が正しくない場合、入力し続ける
行う{
; CH =（CHAR）_getch（）を
「1' }、一方（CH = && CH！ = '2' && CH = '3'）;!
システム（ "CLS"）;
//オプション3、リターン
（CH == '3' IF）
戻り0;
// 1を選択し、読者の優先
他（CH IF = =」1' ）
（） "thread.dat" ReaderPriority。
書き込みをすることが好ましい//オプション2、
他
WriterPriority（ "thread.datを"）;
//エンド
のprintf（ "続行します。"）;
_getch（）。
システム（ "CLS"）。
}
}