Добавил:
wmir
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Инженерия ПЗ Бакалавр / код програм
.txt
// Производитель – потребитель с буфером фиксированного размера (Linux)
int buf[N];
int head, tail;
pthread_mutex_t m;
pthread_cond_t cc; // consumer condvar
pthread_cond_t pc; // producer condvar
void put(int x)
{
pthread_mutex_lock(&m);
while ((tail + 1) % N == head)
pthread_cond_wait(&pc, &m);
buf[tail] = x;
tail = (tail + 1) % N;
if ((head + 1) % N == tail)
pthread_cond_signal(&cc);
pthread_mutex_unlock(&m);
}
////////
int get(void)
{
int val;
pthread_mutex_lock(&m);
while (head == tail)
pthread_cond_wait(&cc, &m);
val = buf[head];
if ((tail + 1) % N == head)
pthread_cond_signal(&pc);
head = (head + 1) % N;
pthread_mutex_unlock(&m);
return val;
}
// ---------------------------------//
// Производитель – потребитель через файл (Линукс)
// прозводитель
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
int cnt = 0;
char buf[32];
char sym = '0';
int c;
//Запись буффера в файл
void writebuf(char *filename, char *message){
FILE *buf;
buf = fopen(filename, "w");
if(!buf)
return;
fprintf(buf, "%s\n", message);
fclose(buf);
}
//Функция заполнения буффера
void setdata(){
for(int i = 0; i < 31; i++)
buf[i] = sym;
buf[31] = 0;
sym++;
writebuf("buf.txt", buf);
}
//Функция обработки сигнала
void handler(int sig){
switch(sig){
case SIGHUP:
//Заполняем буффер
printf("Записываем данные в буффер\n");
setdata();
sleep(20);
kill(c, SIGHUP);
cnt++;
if(cnt == 10)
kill(c, SIGTERM);
break;
case SIGTERM:
printf("Производитель вышел\n");
exit(0);
break;
}
}
//главная функция
int main(int argc, char **cmd){
printf("Производитель запущен");
int lfp, i=0;
c = fork();
if(c == 0){
//создаем процесс подтребителя
execl("consumer", "consumer", "0", 0);
return 0;
}
sleep(20);
setdata();
kill(c, SIGHUP);
//Установка обработчика
signal(SIGHUP, handler);
signal(SIGTERM, handler);
while(true)
sleep(10);
return 0;
}
// потребитель
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
char buf[32];
//Чтения файла в буффер
void readbuf(char *filename){
FILE *file_buf;
file_buf = fopen(filename, "r");
if(!file_buf)
return;
fscanf(file_buf, "%s", buf);
fclose(file_buf);
}
//Обработчик сигнала
void handler(int sig){
switch(sig){
case SIGHUP:
readbuf("buf.txt");
printf("Считали данные: \n%s\n", buf);
sleep(20);
kill(getppid(), SIGHUP);
break;
case SIGTERM:
printf("Потребитель вышел\n");
kill(getppid(), SIGTERM);
exit(0);
break;
}
}
//Главная функция
int main(int argc, char **cmd){
printf("Потребитель запустился\n");
//Установка обработчика
signal(SIGHUP, handler);
signal(SIGTERM, handler);
while(true)
sleep(10);
return 0;
}
// -------------------------------------//
// Читатель-писатель семафор + проекция семафора (Windows)
// Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE Sem =CreateSemaphore(NULL,1,1,"Wr_Sem");
HANDLE Sem2=CreateSemaphore(NULL,1,1,"R_Sem");
int s_reader=0;
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi_w;
PROCESS_INFORMATION pi_r;
TCHAR szComrnandLine_w[]=TEXT("Writer.exe");
TCHAR szComrnandLine_r[]=TEXT("Reader.exe");
HANDLE hFile; // дескрипторы
HANDLE hMapping:
unsigned long int temp;
char *ad;
//---------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{for(int i=0;i<2;i++){
CreateProcess(NULL, szComrnandLine_w, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi_w);
CreateProcess(NULL, szComrnandLine_r, NULL, NULL, FALSE, 0 , NULL, NULL, &si, &pi_r);}
CloseHandle(Sem);
CloseHandle(Sem2);
hFile = CreateFile("File.txt", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
hMapping = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, "FileMapping");
}
// Reader.cpp
#include <vcl.h>
#include <windows.h>
#pragma hdrstop
#include <fstream.h>
#include <stdlib.h>
#pragma argsused
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{ int s_reader=0;
HANDLE Sem_read=OpenSemaphore(SYNCHRONIZE,FALSE,"R_Sem");
HANDLE Sem_write=OpenSemaphore(SYNCHRONIZE,FALSE,"Wr_Sem");
char a[1000];
char next;
hMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,false,"FileMapping");
while(1)
{ WaitForSingleObject(Sem_read,INFINITE);
ad = (String)MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
cout<<ad;
ReleaseSemaphore(Sem_read,1,NULL); }
UnmapViewOfFile(ad);
return 0;}
// Writer.cpp
#include <vcl.h>
#include <windows.h>
#pragma hdrstop
#include <fstream.h>
#pragma argsused
// *** *** **** *** *** *** //
// ------------------------------------- //
// Читатель-писатель мьютекс (Windows)
// Reader.cpp
#include <vcl.h>
#include <fstream.h>
#pragma hdrstop
#pragma argsused
char *ad;
ofstream fp;
fstream f;
int main(int argc, char* argv[])
{
char in_char;
f.open("book.txt",ios::in);
fp.open("readed.txt", ios::app);
while (f.get(in_char))
{
int x=random(10);
if(x==1)
fp<<in_char;
}
fp<<"\n";
fp.close();
f.close();
Sleep(1000);
return 0;
}
// Writer.cpp
#include <vcl.h>
#include <fstream.h>
#pragma hdrstop
#pragma argsused
ofstream file1;
int main(int argc, char* argv[])
{
file1.open("book.txt", ios::app);
for(int i=0;i<10;i++)
file1<<random(1000);
file1.close();
return 0;
}
// Unit1.cpp
#include <windows.h>
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
LPCTSTR MName;
HANDLE h = CreateMutex(NULL,FALSE,MName);
HANDLE hFile; // дескрипторы
HANDLE hMapping:
unsigned long int temp;
void __fastcall TForm1::Button1Click(TObject *Sender)
{
char CommandLine1[] = "Writer.exe";
STARTUPINFO si1;
PROCESS_INFORMATION pi1;
ZeroMemory(&si1,sizeof(STARTUPINFO));
si1.cb = sizeof(STARTUPINFO);
char CommandLine2[] = "Reader.exe";
STARTUPINFO si2;
PROCESS_INFORMATION pi2;
ZeroMemory(&si2,sizeof(STARTUPINFO));
si2.cb = sizeof(STARTUPINFO);
int x=5;
while(x!=0)
{
WaitForSingleObject(h,INFINITE);
OpenMutex(SYNCHRONIZE,FALSE,MName);
CreateProcess(NULL,CommandLine1,NULL,NULL,FALSE,CREATE_NEW_CONSOLE,NULL,NULL,&si1,&pi1);
ReleaseMutex(h);
hMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,false,"FileMapping");
for(int i=0;i<3;i++)
{
hMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,false,"FileMapping");
while(1)
{
ad = (String)MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
cout<<ad;
}
UnmapViewOfFile(ad);
WaitForSingleObject(h,INFINITE);
OpenMutex(SYNCHRONIZE,FALSE,MName);
CreateProcess(NULL,CommandLine2,NULL,NULL,FALSE,CREATE_NEW_CONSOLE,NULL,NULL,&si2,&pi2);
ReleaseMutex(h);
}
x--;
}
hFile = CreateFile("File.txt", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
hMapping = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, "FileMapping");
}
// -----------------------------------------------------------//
// Читатель-писатель (семафор + разделяемая память) (Линукс)
// Писатель:
#include <stdio.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
char w_sem_name[] = "/wsem";
char r_sem_name[] = "/rsem";
sem_t w_sem; /* Семафор, разрешающий записывать в буфер новые данные */
sem_t r_sem; /* Семафор, разрешающий читать данные из буфера */
int main() {
char ch;
int sval;
int shmid;
char *shmaddr;
key_t key;
char str[256];
int i = 0;
shmid=shmget(key,256,0666|IPC_CREAT); /*создаем разделяемую память на 256 элементов */
shmaddr=(char*)shmat(shmid,NULL,0); /* подключаемся к разделу памяти, в shmaddr -- указатель на буфер с разделяемой памятью*/
w_sem = sem_open(w_sem_name,O_CREAT|O_RDWD,0777,1);
r_sem = sem_open(r_sem_name,O_CREAT|O_ RDWD,0777,0);
if(&w_sem == SEM_FAILED || &r_sem == SEM_FAILED) {
perror("error: sem = 0");
return 1;
}
do {
sem_wait(&w_sem);
//... писатель пишет
itoa(i, str, 10);
strcpy(shmaddr, str);
strcpy(str, “”);
i++;
sem_post(&r_sem);
if(sem_getvalue(&w_sem, &sval) == -1) {
perror("wsem sval:");
}
printf("%d",sval);
if(sem_getvalue(&r_sem, &sval) == -1) {
perror("rsem sval:");
}
printf("%d\n",sval);
read(0,&ch,1);
if(ch == '\n') break;
} while (1);
sem_close(&w_sem);
sem_close(&r_sem);
sem_unlink(w_sem_name);
sem_unlink(r_sem_name);
shmctl(shmid,IPC_RMID,NULL); /* уничтожаем разделяемую память */
return 0;
}
// Читатель:
#include <stdio.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
char w_sem_name[] = "/wsem";
char r_sem_name[] = "/rsem";
sem_t w_sem; /* Семафор, разрешающий записывать в буфер новые данные */
sem_t r_sem; /* Семафор, разрешающий читать данные из буфера */
int main() {
char ch;
int sval;
int shmid;
char *shmaddr;
key_t key;
shmid=shmget(key,256,0666|IPC_CREAT); /*создаем разделяемую память на 256 элементов */
shmaddr=(char*)shmat(shmid,NULL,0); /* подключаемся к разделу памяти, в shmaddr -- указатель на буфер с разделяемой памятью*/
w_sem = sem_open(w_sem_name,O_RDWR);
r_sem = sem_open(r_sem_name,O_RDWR);
if(&w_sem == SEM_FAILED || &r_sem == SEM_FAILED) {
perror("error: sem = 0");
return 1;
}
if(sem_getvalue(&w_sem, &sval) == -1) {
perror("wsem sval:");
}
printf("%d",sval);
if(sem_getvalue(&r_sem, &sval) == -1) {
perror("rsem sval:");
}
printf("%d\n",sval);
do {
sem_wait(&r_sem);
//... читатель читает
printf(“reader: %s”, shmaddr);
sem_post(&w_sem);
read(0,&ch,1);
if(ch == '\n') break;
} while (1);
sem_close(&w_sem);
sem_close(&r_sem);
sem_unlink(w_sem_name);
sem_unlink(r_sem_name);
shmctl(shmid,IPC_RMID,NULL); /* уничтожаем разделяемую память */
return 0;
}
// -----------------------------------------//
Производитель – потребитель. (Общая память – Семафор) (Линукс)
// problem
#include <stdio.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <fcntl.h>
#define BUFFER_SIZE 10
#define CONSUMER_SLEEP_SEC 3
#define PRODUCER_SLEEP_SEC 1
#define KEY 1010
// A structure to store BUFER and semaphores for synchronization
typedef struct
{
int buff[BUFFER_SIZE];
sem_t mutex, empty, full;
} MEM;
// Method for shared memory allocation
MEM *memory()
{
key_t key = KEY;
int shmid;
shmid = shmget(key, sizeof(MEM), IPC_CREAT | 0666);
return (MEM *) shmat(shmid, NULL, 0);
}
void init()
{
// Initialize structure pointer with shared memory
MEM *M = memory();
// Initialize semaphores
sem_init(&M->mutex,1,1);
sem_init(&M->empty,1,BUFFER_SIZE);
sem_init(&M->full,1,0);
}
//producer
#include "problem.h"
void producer()
{
int i=0,n;
MEM *S = memory();
while(1)
{
i++;
sem_wait(&S->empty); // Semaphore down operation
sem_wait(&S->mutex);
sem_getvalue(&S->full,&n);
(S->buff)[n] = i; // Place value to BUFFER
printf("[PRODUCER] Placed item [%d]\n", i);
sem_post(&S->mutex);
sem_post(&S->full); // Semaphore up operation
sleep(PRODUCER_SLEEP_SEC);
}
}
main()
{
init();
producer();
}
// consumer
#include "problem.h"
void consumer()
{
int n;
MEM *S = memory();
while(1)
{
sem_wait(&S->full); // Semaphore down operation
sem_wait(&S->mutex); // Semaphore for mutual exclusion
sem_getvalue(&S->full,&n); // Assign value of semphore full, to integer n
printf("[CONSUMER] Removed item [%d]\n", (S->buff)[n]);
sem_post(&S->mutex); // Mutex up operation
sem_post(&S->empty); // Semaphore up operation
sleep(CONSUMER_SLEEP_SEC);
}
}
main()
{
consumer();
}
// ----------------------------------------
// Производитель – потребитель. (Очередь сообщений – Семафор) (Линукс)
struct message{
long type;
int num;
};
// Процесс-производитель
int main()
{
key_t ipckeyMQ = 123;
key_t ipckeySEM = 100;
//Создаём очередь сообщений
int mq_id = msgget(ipckeyMQ, IPC_CREAT | 0666);
//Создаём множество семафоров, состоящего из трёх семафоров
int semset_id = semget(ipckeySEM, 3, IPC_CREAT | 0666);
struct sembuf sb;
//устанавливаем начальное значение семафоров
sb.sem_num = 0; //семафор "пусто"
sb.sem_op = 1;
sb.sem_flg = 0;
semop(semset_id, &sb, 1);
//семафор "полный" под номером 1
sb.sem_num = 2; //семафор взаимоисключающего доступа
sb.sem_op = 1;
sb.sem_flg = 0;
semop(semset_id, &sb, 1);
while(1)
{
message msg;
msg.num = 333;
msg.type = 1;
sb = { 0, -1, 0 }; //можно заполнять те три поля еще и так
semop(semset_id, &sb, 1); //операция над семафором
sb = { 2, -1, 0 };
semop(semset_id, &sb, 1);
//Заносим сообщение в очередь
int rec = msgsnd(mq_id, (struct msgbuf*) (&msg), sizeof(msg.num), 0);
sb = { 2, 1, 0 };
semop(semset_id, &sb, 1);
sb = { 1, 1, 0 };
semop(semset_id, &sb, 1);
}}
// Процесс-потребитель
int main()
{
key_t ipckeyMQ = 123;
key_t ipckeySEM = 100;
//Находим очередь сообщений, которую создал производитель
int mq_id = msgget(ipckeyMQ, 0);
//Находим созданное множество семафоров
int semset_id = semget(ipckeySEM, 3, 0);
struct sembuf sb;
while(1)
{
message msg;
sb = { 1, -1, 0 };
semop(semset_id, &sb, 1);
sb = { 2, -1, 0 };
semop(semset_id, &sb, 1);
//Извлекаем сообщение из очереди
int rec = msgrcv(mq_id, (struct msgbuf*) (&msg), sizeof(msg.num), 0, 0);
sb = { 2, 1, 0 };
semop(semset_id, &sb, 1);
sb = { 0, 1, 0 };
semop(semset_id, &sb, 1);
}
}
Соседние файлы в папке Инженерия ПЗ Бакалавр