Lab2_Threads_z3

import java.util.HashSet;
import java.util.Scanner;
import java.util.concurrent.Semaphore;

public class Naizmenicno {

    public static int NUM_RUNS = 10000;

    int f1count;
    int f2count;
    int maxDifference = 0;

    /**
     * Metod koj treba da gi inicijalizira vrednostite na semaforite i
     * ostanatite promenlivi za sinhronizacija.
     *
     */
    Semaphore sem1;
    Semaphore sem2;


    public void init(int count) {
       maxDifference = count;
       f1count = 0;
       f2count = 0;
        //f1 ke se isprinta max count pati a posle ke mora f2 za da mu relesova pa da moze pak f1
       sem1 = new Semaphore(count);
        //so sekoe izvrsuvanje na f1, f2 dobiva release i dozvola za izvrsuvanje
       sem2 = new Semaphore(0);
    }

    class F1Thread extends Thread {

        public void executeF1() throws InterruptedException {
            sem1.acquire();
                //potreben e mutex bidejki f1 i f2 koristat spodeleni promenlivi od istata klasa.....
            synchronized (Naizmenicno.class) {
                f1();
            }

            sem2.release();

        }

        @Override
        public void run() {
            try {
                executeF1();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    class F2Thread extends Thread {

        public void executeF2() throws InterruptedException {
           sem2.acquire();
           synchronized (Naizmenicno.class) {
               f2();
            }

           sem1.release();
        }

        @Override
        public void run() {
            try {
                executeF2();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void f1() {
        System.out.println("f1()");
        f1count++;
        if (f1count - f2count > maxDifference) {
            maxDifference = f1count - f2count;
        }
    }

    public void f2() {
        System.out.println("f2()");
        f2count++;

        if (f1count - f2count > maxDifference) {
            maxDifference = f1count - f2count;
        }
    }

    public static void main(String[] args) {
        try {
            Naizmenicno environment = new Naizmenicno();
            environment.start();


        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void start() throws Exception {

        System.out.println("Vnesete za kolku poveke sakate da se izvrsi f1()");
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        init(n);

        HashSet<Thread> threads = new HashSet<Thread>();
        for (int i = 0; i < NUM_RUNS; i++) {
            F1Thread f1 = new F1Thread();
            F2Thread f2 = new F2Thread();
            threads.add(f1);
            threads.add(f2);
        }

        for (Thread t : threads) {
            t.start();
        }

        for (Thread t : threads) {
            t.join();
        }
        System.out.println("F1count: " + f1count);
        System.out.println("F2count: " + f2count);
        System.out.println("maxDifference: " + maxDifference);
        System.out.println("Status: " + (maxDifference <= n));
    }
}