사용법 #include "WINDOWS.H"
#INCLUDE <conio.h와>
#INCLUDE <stdlib.h>
#INCLUDE <io.h>
#INCLUDE <문자열>
#INCLUDE <conio.h와>
#INCLUDE <fstream>
네임 스페이스를 사용하여 표준;
#DEFINE READER 'R'// 독자
#DEFINE WRITER 'W'// 라이터
#DEFINE INTE_PER_SEC 1,000 // 클럭 초당 인터럽트 수
#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는) {
//互斥变量
핸들 h_Mutex;
h_Mutex = OpenMutex (MUTEX_ALL_ACCESS, FALSE "mutex_for_readcount");
DWORD의 wait_for_mutex, 뮤텍스 변수 소유권을 기다리고 //
DWORD의 m_delay; // 지연
DWORD의 m_persist; // 읽기 파일 기간
INT m_serial, 스레드 // 숫자;
// 매개 변수의 정보를 얻을
m_serial = ((ThreadInfo에 *) ( 쪽 )) -> 시리얼;
m_delay = (DWORD) (((ThreadInfo에 *) (P)) -> 지연 * INTE_PER_SEC)
m_persist = (DWORD) (((ThreadInfo에 *) (P)) -> (가)) * INTE_PER_SEC 유지;
수면 (m_delay); // 지연 대기
의 printf ( "리더 스레드 % 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에) (ρ-))의 -> (가)) * 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를 숯불 * 파일) {
DWORD n_thread = 0; // 스레드 번호
DWORD thread_ID는; //은 ID 계속
DWORD의 wait_for_all을, 모든 스레드의 끝 // 대기
// 뮤텍스 개체
핸들 h_Mutex,
h_Mutex CreateMutex = (NULL, FALSE, "mutex_for_readcount");
// 객체의 배열 계속
[MAX_THREAD_NUM] h_Thread HANDLE
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 ++) {
경우 ([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); //创建读者线程
}
다른 경우 ([I] .entity == 'W'thread_info thread_info [I] == .entity WRITER ||) {
//创建写者线程
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- 형을 완료되었습니다.");
}
// 플러스 쓰기 - 리더 프로세스
// P : 독자 스레드 정보
{무효 WP_ReaderThread (무효 * P는)
//互斥变量
핸들 h_Mutex1;
h_Mutex1 = OpenMutex (MUTEX_ALL_ACCESS, FALSE "mutex1");
핸들 h_Mutex2;
h_Mutex2 = OpenMutex (MUTEX_ALL_ACCESS, FALSE "mutex2");
DWORD의 wait_for_mutex1, 뮤텍스 변수 소유권을 기다리고 //
DWORD의 wait_for_mutex2,
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와는 ( ". % d 개의 독자 \ N- 형 대기"m_serial)
wait_for_mutex1 =의 WaitForSingleObject (h_Mutex1, -1);
// 중요한 부분 리더기를 입력
EnterCriticalSection (cs_Read는)
뮤텍스 mutex2 차단 상기 readcount 액세스를 보장하기 위해 // 배타적 수정
WaitForSingleObject이 (h_Mutex2, -1)을 wait_for_mutex2 =;
// 수정 독자
ReadCount ++;
IF (. ReadCount == 1) {
마무리 // 제 경우 리더, 라이터 대기
EnterCriticalSection (cs_Write)
}
ReleaseMutex (h_Mutex2); // 릴리스 뮤텍스 mutex2
// 다른 독자가 중요 섹션 입력 할 수 있습니다
(cs_Write)를 LeaveCriticalSection을,
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;
// 뮤텍스
핸들 h_Mutex3;
h_Mutex3 = OpenMutex (MUTEX_ALL_ACCESS, FALSE "mutex3");
// 파라미터의 정보를 얻는
, 직렬> - m_serial = (합니다 (ThreadInfo에 *)를 (P))
- m_delay = (DWORD) (> * 지연 INTE_PER_SEC (합니다 (ThreadInfo에 *) (P)))
(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를);
// 뮤텍스 차단 mutex3가 writercount에 액세스 할 수 있도록, 변형 뮤텍스
wait_for_mutex3가의 WaitForSingleObject = (h_Mutex3, -1);
writecount--; // 독자의 번호는 개질
IF (writecount == 0) {
완료 // 라이터 독자가 읽을 수
LeaveCriticalSection (cs_Read를)
}
ReleaseMutex (h_Mutex3를)
}
// 쓰기 선호하는 핸들러
// 파일 : 파일 이름
무효 WriterPriority (const를 숯불 * 파일) {
DWORD n_thread = 0; 스레드 // 수
DWORD thread_ID; // ID 스레드
DWORD의 wait_for_all을, 모든 스레드의 끝 // 대기
// 상호 발수 오브젝트
핸들 h_Mutex1;
h_Mutex1 = CreateMutex (NULL, FALSE "mutex1");
핸들 h_Mutex2;
h_Mutex2 = CreateMutex (NULL, FALSE "mutex2");
핸들 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, 숯불 * argv와 []) {
숯 CH;
(참까지) 동안 {
의 printf ( "************************************************************ *************** \ N- 형 ");
printf와 ("1. 독자 스레드 \ N- 형 ");
printf와 ("2. 작가 스레드 \ N- 형 ");
printf와 ("3. 종료 스레드 \ N- 형 ");
printf와 ("************************************* \ "는 N- )
의 printf ( "입력 또는 1,2- 3.");
상기 입력 정보가 올바르지 않으면 // 엔터 계속
DO {
CH = (숯) _getch를 ();
} while 회 (CH = '. 1'&& CH! = '2'&& CH = '3') ;!
시스템 ( "CLS");
// 옵션 3, 반환
(CH == '3') 경우
0을 반환;
// 선택 1, 독자의 우선 순위
경우 다른 (CH = = '. (1'))
() "thread.dat"ReaderPriority;
작성 선호 // 옵션 2,
다른
( "thread.dat") WriterPriority;
// 끝
에서 printf ( "계속 입력 :");
_getch ();
시스템 ( "CLS");
}
}