atleta

/*********************

Modelovati klasu AtletskoOkupljanje

Na Atletskom okupljanju postoje 2 vrste aktivnosti, tj takmicara.
Postoje bacaci koplja i skakaci u dalj.
Svi takmicari za svoje vrsenje aktivnosti koriste ZALETISTE
SAmo 1 takmicar moze u jednom trenutku da ga koristi, drugi moraju da cekaju dok ne bude slobodno
Takmicari vrse svoje aktivnosti naizmenicno jedan u odnosu na drugog.

Bacaci koplja bacaju koplje na daljinu od 0 do 100 metara
Bacanje koplja traje 2 sekunde

Skakaci skacu od 0 do 9 metara
Skakanje traje 1 sekundu.

Neophodno je izmeriti ukupno trajanje aktivnosti takmicara
( cekanje+ skok/bacanje)

Ponasanje skakaca opisuje funkcija skakac
Ponasanje bacaca opisuje funkcija bacac

***********************************/

#include<iostream>
#include<thread>
#include<string>
#include<cstdlib>
using namespace std;
using namespace chrono;


int rand_sync() {
        static mutex mx;
        lock_guard<mutex> l(mx);
        return rand();
}

struct povratna_vrednost{
    int duzina;
    duration<double, milli> trajanje;
    monotonic_clock::time_point dosao;
    monotonic_clock::time_point poceo;
    monotonic_clock::time_point zavrsio;
    duration<double, milli> cekanje;
    duration<double, milli> servis;

    };

    enum NaRedu{SKAKAC=0,BACAC};

class AltetskoOkupljanje{
    private:
        mutex m;
        condition_variable bacaci;
        condition_variable skakaci;

        bool zaletiste_slobodno;

        NaRedu enum_na_redu;

        size_t broj_niti_skakaca;
        size_t broj_niti_bacaca;

    public:
    AltetskoOkupljanje(size_t skakaci, size_t bacaci){
     broj_niti_skakaca=skakaci;
      broj_niti_bacaca=bacaci;
       enum_na_redu=SKAKAC;
        zaletiste_slobodno=true;
        }

    povratna_vrednost skoci(){


        povratna_vrednost pov;
            pov.dosao = monotonic_clock::now();
                {
                unique_lock<mutex>l(m);
                while(enum_na_redu!=SKAKAC || zaletiste_slobodno==false){
                    skakaci.wait(l);
                }

                zaletiste_slobodno = false;
                pov.poceo = monotonic_clock::now();
                pov.duzina = rand_sync()%10;

                this_thread::sleep_for(seconds(1));
                pov.zavrsio =  monotonic_clock::now();
                 broj_niti_skakaca--;


                if(broj_niti_bacaca>0){
                enum_na_redu =BACAC;
                zaletiste_slobodno=true;
                bacaci.notify_one();
                } else
                    {
                    zaletiste_slobodno=true;
                    skakaci.notify_one();
                    }

                }
                pov.cekanje = pov.poceo-pov.dosao;
                pov.servis = pov.zavrsio-pov.poceo;
                pov.trajanje = pov.cekanje+pov.servis;
                return pov;

    }

    povratna_vrednost BaciKoplje(){
        povratna_vrednost pov;
               pov.dosao = monotonic_clock::now();

       {
        unique_lock<mutex>l(m);
                while(enum_na_redu!=BACAC || zaletiste_slobodno==false)
                    bacaci.wait(l);

                zaletiste_slobodno = false;
                pov.poceo = monotonic_clock::now();
                pov.duzina = rand_sync()%101;

                this_thread::sleep_for(seconds(2));
                pov.zavrsio =  monotonic_clock::now();
                 broj_niti_bacaca--;



                if(broj_niti_skakaca>0){
                enum_na_redu =SKAKAC;
                zaletiste_slobodno=true;
                skakaci.notify_one();
                } else
                    {
                    zaletiste_slobodno=true;
                    bacaci.notify_one();
                    }


       }

                pov.cekanje = pov.poceo-pov.dosao;
                pov.servis = pov.zavrsio-pov.poceo;
                pov.trajanje = pov.cekanje+pov.servis;
                return pov;


    }
};

mutex term_m;
    void skakac ( AltetskoOkupljanje& ao, size_t redni_Br){
    povratna_vrednost p;
    p=ao.skoci();
    duration<double, milli> ukupno=p.trajanje;
    lock_guard<mutex> l(term_m);
    cout<<"Takmicar br " << redni_Br<< "skocio: " << p.duzina << "m, ukupna aktivnost u milisekundama: "
    << ukupno.count() << endl;
    }

void bacac ( AltetskoOkupljanje& ao, size_t redni_Br){
    povratna_vrednost p;
    p=ao.BaciKoplje();
    duration<double, milli> ukupno=p.trajanje;
    lock_guard<mutex> l(term_m);
    cout<<"Takmicar br " << redni_Br<< "bacio: " << p.duzina << "m, ukupna aktivnost u milisekundama: "
    << ukupno.count() << endl;
}

const size_t SKAKACI=3;
const size_t BACACI=6;
const size_t UKUPNO = SKAKACI+BACACI;
int main(){
    AltetskoOkupljanje ao(SKAKACI,BACACI);
    thread skakaci[SKAKACI];
    thread bacaci[BACACI];

    for(size_t i=0; i<SKAKACI; ++i){
        skakaci[i]=thread(skakac, ref(ao), i+1);
    }
    for(size_t i=0; i<BACACI; ++i){
        bacaci[i]=thread(bacac, ref(ao), i+1);
    }

    for(size_t i=0; i<SKAKACI; ++i){
        skakaci[i].join();
    }
    for(size_t i=0; i<BACACI; ++i){
        bacaci[i].join();
    }

    cout<< "KRAJ PROGRAMA"<<endl;
}