OS_4_ANZH

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

#include <thread>

#include <ctime>

#include <cstdlib>

#include <windows.h>

#include <stdio.h>

#include <string.h>

#include <random>

using namespace std;

class GETtime {

public:
    int milisecTotal;
    int min_t;
    int sec_t;
    int MSCostatok;
    void endT() {
        tEnd = std::chrono::high_resolution_clock::now();
        chrono::duration < float > duration = (tEnd - tStart) * 1000;
        GETtime::milisecTotal = duration.count();
        GETtime::min_t = (duration.count() / 1000 / 60);
        GETtime::sec_t = int(duration.count() / 1000) % 60;
        GETtime::MSCostatok = int(duration.count()) - min_t * 60 * 1000 - sec_t * 1000;
        chrono::duration < float > Tstrt = tStart - tStart;
        cout << "Tend: " << duration.count() << endl;
    }
    void strtT() {
        tStart = std::chrono::high_resolution_clock::now();
        chrono::duration < float > Tstrt = tStart - tStart;
        cout << "Tstrt: " << Tstrt.count() << endl;
    }
    void print_Iter() {
        cout << "min- " << GETtime::min_t << "sec- " << GETtime::sec_t << "milSec- " << GETtime::MSCostatok << endl;
    }
private:
    std::chrono::time_point < std::chrono::steady_clock > tStart, tEnd;
};

GETtime t;
class Bufer {
public:
    int p;
    HANDLE sem_P1 = sem_P1_fun();
    HANDLE sem_P1_fun() {
        sem_P1 = CreateSemaphore(NULL, 1, 1, L"SemaphoreP1");
        return sem_P1;
        CloseHandle(sem_P1);
    }

    void massivPP() {
        p++; p++;

        if (p == 332) {
            t.endT();
            system("PAUSE");
            exit(1);
        }
    }

public:
    int print;
    HANDLE sem_P2 = sem_P2_fun();
    HANDLE sem_P2_fun() {
        sem_P2 = CreateSemaphore(NULL, 1, 1, L"MySemaphoreNameT2");
        return sem_P2;
        CloseHandle(sem_P2);
    }

    void PrintOne() {
        cout <<"<"<<print << ">";
    }
    //  буфер принимает элемент для записи
public:
    HANDLE SembuferF;
    const int SIZE = 8;
    int* bufer = new int[SIZE];
    int steps;
    int puted;

    HANDLE SembuferFfer() {
        SembuferF = CreateSemaphore(NULL, 8, 8, L"SemaphorebuferF");
        return SembuferF;
    }
    void put() {
        if (0 == steps % 8) {
            ReleaseSemaphore(SembuferF, 8, NULL); // обнуление буфера освобождение
            cout << "\n";
            printARR();
        }
        bufer[steps % 8] = puted;
        cout << "{" << bufer[steps % 8] << "}";

        steps++;
        WaitForSingleObject(SembuferF, INFINITE); // счетчик максимально заполнение буфера
    }

    void printARR() { // печать проверка
        int i = 0;
        while (i < SIZE) {
            cout << "bufer (" << i << ") " << bufer[i] << endl;
            i++;
        }
    }

private:
};

Bufer bufer;

void ThreadN_1P(Bufer& bufer) { //добавляем в буфер

    Sleep(300);
    int i = 0;

    t.strtT();
    while (1) {
        bufer.massivPP(); // увеличиваем массив
        bufer.puted = bufer.p;
        bufer.put(); // добавляем в буфер
        WaitForSingleObject(bufer.sem_P2, INFINITE); // блокировка ввода
        ReleaseSemaphore(bufer.sem_P1, 1, NULL); //разрешение печати
        i++;
    }
}

void ThreadN_2P(Bufer& bufer) { // печатаем из буфера

    Sleep(300);
    int i = 0;

    while (1) {
        bufer.print = bufer.puted; // печатаем
        bufer.PrintOne();
        WaitForSingleObject(bufer.sem_P1, INFINITE); // блокировка печати
        ReleaseSemaphore(bufer.sem_P2, 1, NULL); //разрешение ввода
        i++;
    }

}

DWORD WINAPI ThreadN_1(LPVOID lpParam) { //поток 1

    ThreadN_1P(bufer);
    return 0;
}

HANDLE CreateThread_1(Bufer& bufer, int nPtr) { //nPtr это приоритет потока

    HANDLE hThrMassSort;
    DWORD ThrID;

    hThrMassSort = CreateThread(
        NULL,
        0,
        ThreadN_1, &
        bufer // massiv parametrov
        ,
        CREATE_SUSPENDED, &
        ThrID
    );

    if (hThrMassSort == NULL) {
        cout << "Thread-failed" << GetLastError() << endl;
    }

    SetThreadPriority(hThrMassSort, nPtr); // THREAD_PRIORITY_NORMAL = 0
    cout << "Priorytet hThread-mass-sort = " << GetThreadPriority(hThrMassSort) << endl;
    cout << "Thread-Creation-Success" << endl;
    ResumeThread(hThrMassSort); /// start potoka
    cout << "ThreadID=" << ThrID << endl;
    return hThrMassSort;
}

DWORD WINAPI ThreadN_2(LPVOID lpParam) { // поток-2
    cout << "Thread-Running-2" << endl;
    ThreadN_2P(bufer);
    return 0;
}

HANDLE CreateThread_2(Bufer& bufer, int nPtr) { //nPtr это приоритет потока
    HANDLE hThrMassSort;
    DWORD ThrID;

    hThrMassSort = CreateThread(
        NULL,
        0,
        ThreadN_2, &
        bufer // arr parametrov
        ,
        CREATE_SUSPENDED, &
        ThrID
    );

    if (hThrMassSort == NULL) {
        cout << "Thread-failed" << GetLastError() << endl;
    }
    //set prioritet
    SetThreadPriority(hThrMassSort, nPtr); //THREAD_PRIORITY_NORMAL = 0
    cout << "Priorytet-Thread-2" << GetThreadPriority(hThrMassSort) << endl;
    cout << "Thread-Creation-Success" << endl;
    ResumeThread(hThrMassSort); /// start potoka
    cout << "ThreadID=" << ThrID << endl;
    return hThrMassSort;
}

void main() {

    HANDLE hThrMassSort1 = CreateThread_1(bufer, 15);
    HANDLE hThrMassSort2 = CreateThread_2(bufer, -15);

    Sleep(4000);
    bufer.printARR();
    CloseHandle(hThrMassSort1);
    CloseHandle(hThrMassSort2);
}