Bar

#include<Windows.h>
#include<process.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<iostream>
#include<vector>

using namespace std;

#define r 80//número de rodadas
#define x 4//número de garçons
#define c 36//número de clientes
#define k 4//capacidade dos garçons

typedef struct{
    bool clienteEsperaPedido;
    int id;
}parametroCliente;

typedef struct{
    int id;
}parametroGarcon;

HANDLE mutexGarcon[x];
HANDLE mutexVideo;
HANDLE mutexRodada;
HANDLE eventCliente[c];


int numeroPedidos[x] = {0};
int matrizCliente[x][k]; // gardar os ids dos clientes que pediram para determinado garcon
int topo[x] = {0};
int rodadas = 0;

void CriarThreadsClientes(HANDLE idThread[], parametroCliente parametro[], DWORD ThreadIdentifier[]);
void CriarThreadsGarcon(HANDLE idThread[], parametroGarcon parametro[], DWORD ThreadIdentifier[]);
void IniciarThreads(HANDLE idThread[], int n);
void FecharThread(HANDLE idThread[], int n);
void criarMutex();
void criarEvent();
void fazPedido(parametroCliente *par);
void esperaPedido(int id);
void recebePedido(bool *clienteEspera);
void cliente(void *parametro);
void recebePedidoMaximo(int idgarcon);
void registraPedido(int idgarcon);
void entregaPedido(int idgarcon);
void garcon(void *parametro);
bool fechoubar();


int main()
{
    srand(time(NULL));

    DWORD clienteIdentifier[c];
    HANDLE idCliente[c];
    parametroCliente parCli[c];


    DWORD garconIdentifier[x];
    HANDLE idGarcon[x];
    parametroGarcon parGar[x];

    criarMutex();
    criarEvent();

    printf("Criando threads clientes\n");
    CriarThreadsClientes(idCliente, parCli, clienteIdentifier);

    printf("Criando threads Garcom\n");
    CriarThreadsGarcon(idGarcon, parGar, garconIdentifier);

    IniciarThreads(idCliente, c);
    IniciarThreads(idGarcon, x);

    WaitForMultipleObjects(c, idCliente, TRUE, INFINITE);
    WaitForMultipleObjects(x, idGarcon, TRUE, INFINITE);

    FecharThread(idCliente, c);
    FecharThread(idGarcon, x);


    return 0;
}


void CriarThreadsClientes(HANDLE idThread[], parametroCliente parametro[], DWORD ThreadIdentifier[])
{
    for(int i = 0; i < c; i++)
    {
        parametro[i].id = i;
        idThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)cliente, &parametro[i], CREATE_SUSPENDED, &ThreadIdentifier[i]);

    }
}

void CriarThreadsGarcon(HANDLE idThread[], parametroGarcon parametro[], DWORD ThreadIdentifier[])
{
    for(int i = 0; i < x; i++)
    {
        parametro[i].id = i;
        idThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)garcon, &parametro[i], CREATE_SUSPENDED, &ThreadIdentifier[i]);

    }
}

void IniciarThreads(HANDLE idThread[], int n)
{
        for(int i = 0; i < n; i++)
        {
            ResumeThread(idThread[i]);
        }
}

void FecharThread(HANDLE idThread[], int n)
{
    for(int i = 0; i < n; i++)
    {

        CloseHandle(idThread[i]);

    }
}


void criarMutex()
{
    mutexVideo = CreateMutex(NULL, FALSE, NULL);
    mutexRodada = CreateMutex(NULL, FALSE, NULL);


    for(int i = 0; i < x; i++)
    {

        mutexGarcon[i]= CreateMutex(NULL, FALSE, NULL);
    }
}

void criarEvent()
{
    for(int i = 0; i < c; i++)
    {
         eventCliente[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
    }


}

void fazPedido(parametroCliente *par)
{

    int gar;

    WaitForSingleObject(mutexRodada, INFINITE);
        do{
            gar = rand() % x;
        }while(topo[gar] < k);
    ReleaseMutex(mutexRodada);

    WaitForSingleObject(mutexVideo, INFINITE);
        cout << "Cliente " << par->id <<  " faz pedido" << endl << endl;
    ReleaseMutex(mutexVideo);

    WaitForSingleObject(mutexGarcon[gar], INFINITE); //Apenas um cliente pede por vez a um único garçom
        numeroPedidos[gar] += 1;
        matrizCliente[gar][topo[gar]] = par->id;
        topo[gar] += 1;
        par->clienteEsperaPedido = true;
    ReleaseMutex(mutexGarcon[gar]);



}

void esperaPedido(int id)
{
    WaitForSingleObject(eventCliente[id], INFINITE);
}

void recebePedido(bool *clienteEspera)
{
    *clienteEspera = false;
}

void consomePedido()
{

    Sleep(500 + rand() % 500);
}

void cliente(void *parametro)
{
    parametroCliente *par = (parametroCliente *) parametro;

    while(!fechoubar())
    {
        fazPedido(par);
        esperaPedido(par->id);
        recebePedido(&(par->clienteEsperaPedido));
        consomePedido();
    }

}

void recebePedidoMaximo(int idgarcon)
{

    while(numeroPedidos[idgarcon] <= k)
    {

    }
}

void registraPedido(int idgarcon)
{
    WaitForSingleObject(mutexGarcon[idgarcon], INFINITE); // por enquanto ninguem mais pede a este garcon


}

void entregaPedido(int idgarcon)
{
    for(int i = 0; i < k ; i++)
    {
        PulseEvent(eventCliente[matrizCliente[idgarcon][i]]);
        numeroPedidos[idgarcon] -= 1;
        topo[idgarcon] -= 1;
    }

    ReleaseMutex(mutexGarcon[idgarcon]);

}

void garcon(void *parametro)
{
    parametroGarcon *par = (parametroGarcon *) parametro;

    while(!fechoubar())
    {
        recebePedidoMaximo(par->id);
        registraPedido(par->id);
        entregaPedido(par->id);

        WaitForSingleObject(mutexRodada, INFINITE);
            rodadas++;
        ReleaseMutex(mutexRodada);
    }
}

bool fechoubar()
{
    if(rodadas < r)
    {

        return(false);
    }

    else
    {
        return(true);
    }
}