AV2 Threads and Conccurency

package AV2;

import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    public static void main(String[] args) throws InterruptedException {
//        System.out.println("Exdecution into the main class");
//
//        ThreadClass thread1=new ThreadClass();
        //thread1.run(); //so run ne se kreira nova niska tuku samo run metodot se vrsi vo main
        //za da se kreira nova niska i taa da se izvrsuva posebno mora start namesto run
        // thread1.start(); //kreiranje na nova niska
        //ist output no naredba za sout od ThreadClass se izvrsuva vo posebna niska+
//povik na inrecementor
        Incrementor incrementor1 = new Incrementor();
        Incrementor incrementor2 = new Incrementor();
        //za da mozeme count (vo ovoj slucaj) da go zgolemime vo run metodoto t.e niskite da rabotat so incrementorot mora vo thread clasata da se deklaraira incrementor

        ThreadClass t1 = new ThreadClass("T1", incrementor1);
        ThreadClass t2 = new ThreadClass("T2", incrementor2);

        t1.start();
        t2.start();

        //se vrsat naizmenicno bidejki schedueler im ima dadeno razlicni time slots vo koi treba da rabotat i imaat nepredvidlivi izvrsuvanja

        //se dodeka ne se izvrsi prviot del i se dodeka ne se izvrsi vtoriot del cekaj:::
        t1.join();
        t2.join();
        //vo join mozeme da vneseme argument sto znaci za kolku vreme da zavrsi eden thread
        //cekaj da zavrsi za 5 skeundi , ako ne zavrsi prodolzi so dr instrukcii

        ///VRATI SE NA OVA POSLE
//        if(t1.isAlive() && t2.isAlive())
//        {
//            //ne preminal vo sostojba dead
//            System.out.println("Thread is still alive");
//            //tuka pravime prisilen interrupt -> da premine threadot vo sostojva dead
//            t1.interrupt();
//            t2.interrupt();;
//        }

        System.out.println(incrementor1.getCount());
        System.out.println(incrementor2.getCount());
        //se dodeka ne se izvrsat threadovite nema da dojdeme do pecatenjeto(vo ovoj slucaj)
        //mainot pobrzo stignuva do pecatenjeto kako proces otkolku zanimavanjeto so niskite
        //so join metod pravime stop na main dodeka ne zavrsi niska1 + niska2 ->se do togas ne izvrsuvaj nesto so se naoga posle niv


    }
}

class Incrementor {
    private static int count = 0;
    //so static count ni e spodelena vrednost
    private static Semaphore semaphore = new Semaphore(2); //samo 1 thread da moze da pristapuva do kriticniot domen

    //lock i unlock promenliva za mutex
    private Lock lock = new ReentrantLock(); //vo pozadina ima implementacija na mutex

    public static void unsafeIncrement() throws InterruptedException {
        count++;
        //read count
        //increment count +1
        //write count
        //count promenlivata e kriticen domen bidejki poveke procesi probuvaat da pristapat do ovaa promenliva i zatoa count ne e atomicna operacija

        ThreadClass.sleep(5);
        //thread vo koj se naogame da spie 5 sekundi dodeka ne se izvrsi count
    }

    public static int getCount() {
        return count;
    }

    public static void safeSemaphorIncrement() throws InterruptedException {
        semaphore.acquire(); //acquire ni kazuva deka nasiot semafor vo daden moment pravii acquire na nekoj od threadovite
        //kolku permirs->tolku acquires
        //predava permit na sleden koj ceka
        count++;
    }

    public synchronized void safeIncrement() {
        count++;
        //za daden monitor ovaa f-ja da e sinhronziiran
        //monitor e samiot objekt/proces vo koj se naogame
        //mesto kade so mozeme da izvrsuvamme rab samo ako se naogame vo nego se dodeka ne zavrsi monnitoor na odreden thread nemoze dr thread da pristapi do ovaa fja
//        synchronized (this)
//        {
//            count++;
//        }
    }

    public void safeClassIncrement() {
        synchronized (Incrementor.class) {
            count++;
            //sinhronizacija na nivo na klas
        }
    }

    public void safeMutexIncrement() {
        //koga ke pristapime do fja zakluci ja elijata kade sto e count
        //pristapi zgolemi vrednost pa potoa napravi unlock
        lock.lock();
        count++;
        lock.unlock();
    }

    //mutex e kluc ->go imame klucot i mozeme da pristapime do memorijata i lock_ja menuvame morijata unlock go davame klucot na sledniot thread koj ceka
    //vo incrementorot postavuvame lock promenliva

}

//mora override na run metoda
//run metod se pojavuva koja kreriame nova niska
//main metod ni e primarna niska od koja se povikvuvaat ostanati niski koi se kreiraar vo samata metoda
class ThreadClass extends Thread {

    String name;
    Incrementor incrementor;

    public ThreadClass(String name, Incrementor incrementor) {
        this.name = name;
        this.incrementor = incrementor;
    }
    //sekoja instanca od thread class ke ima svoj incrementor


    @Override
    public void run() {
        //System.out.println("Execution in the Thread class");

        for (int i = 0; i < 20; i++) {
            //System.out.println("Thread:" + name + ": " + i);
            incrementor.safeMutexIncrement();
        }
    }
}

//semaforot ostava poveke da pristapuvaat do kriticniot domen za razlika od mutex koj ostava samo eden
//vo semaforot() kako argument dozvoluvame t.e kazuvame kolku saamee da mozat da prisatapt do kriticniot domen