Инженерия ПЗ Бакалавр / код програм

// Производитель – потребитель с буфером фиксированного размера (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);
            }
        }