(Java) OS: Lab 3 - ОС: Лаб 3

/*
Task 1 Problem 1 (1 / 1)
You are hired by the show „Dancing with the students“, in order to implement a software solution which will automatically control the gates which guide the contestants.

The entry gate leads directly to one of the changing rooms, where the contestants should change their clothes. You can have at most 10 contestants in each changing room, at the same time.

After they change, the contestants wait for a random partner from the opposite gender, after which they exit the changing room and enter the dancing room. The dancing room can have a maximum of three pairs dancing at the same time (in parallel). After they finish dancing, the pairs exit the dancing room leaving space for a new pair to enter and start dancing.

In the starter code, you have the definition of two classes, Masko (Male) and Zensko (Female), which represent contestants from the corresponding gender. Each of the classes has multiple running instances, and each instance can dance only once.

In your implementation, you can use the following methods from show:

show.presobleci()
Represents a contestant entering in the changing room and changing
Cannot be called in parallel by more than 10 contestants from the same gender
show.tancuvaj()
Represents the start of the dance
Can only be called by male contestants, as they lead the dance
The male contestant should make sure that a female contestant is present as his partner before he makes the call
There cannot be more than 3 parallel calls on this method
These methods manipulate with a shared resource and are not atomic.

Your task is to implement the methods Masko.ucestvo(), Zensko.ucestvo() and init(). In your implementation, you can not add try-catch blocks in them. You should define the necessary semaphores, global variables and state variables.

If you have an error, you will get this message:

Procesot ne e sinhroniziran spored uslovite na zadacata // The process in not synchronized according to the conditions in the task

After that you will see the log of actions and errors. Use this log to see what went wrong,

Note: Due to concurrent execution of the logging, it is possible that some of the messages in the log are not in the position they are supposed to be. Therefore, use them only as guideline information, do not base all of the conclusions on them.
*/

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Semaphore;

public class TancSoStudentite {
    //TODO: Definicija na globalni promenlivi i semafori
    private static Semaphore enterMaleChangingRoom;
    private static Semaphore enterFemaleChangingRoom;
    private static Semaphore enterDancingRoom;
    private static Semaphore readyFemales;
    private static Semaphore readyToDance;


    public void init() {
        //TODO: da se implementira
        enterMaleChangingRoom = new Semaphore(10);
        enterFemaleChangingRoom = new Semaphore(10);
        enterDancingRoom = new Semaphore(3);
        readyFemales = new Semaphore(0);
        readyToDance = new Semaphore(0);
    }

    class Masko extends Thread {
        //TODO: Definicija  na promenlivi za sostojbata

        public void ucestvo() throws InterruptedException {
            //TODO: da se implementira
            enterMaleChangingRoom.acquire();
            show.presobleci();
            readyFemales.acquire();
            // samo maskoto go povikuva metodot tancuvaj
            readyToDance.release();
            enterMaleChangingRoom.release();

            enterDancingRoom.acquire();
            show.tancuvaj();
            enterDancingRoom.release();
        }

        @Override
        public void run() {
            try {
                ucestvo();
            } catch (InterruptedException e) {
                // Do nothing
            } catch (Exception e) {
                exception = e;
                hasException = true;
            }
        }

        @Override
        public String toString() {
            return String.format("m\t%d", getId());
        }
        public Exception exception = null;
    }

    class Zensko extends Thread {
        //TODO: Definicija  na promenlivi za sostojbata

        public void ucestvo() throws InterruptedException {
            //TODO: da se implementira
            enterFemaleChangingRoom.acquire();
            show.presobleci();
            readyFemales.release();
            readyToDance.acquire();
            enterFemaleChangingRoom.release();
        }

        @Override
        public void run() {
            try {
                ucestvo();
            } catch (InterruptedException e) {
                // Do nothing
            } catch (Exception e) {
                exception = e;
                hasException = true;
            }
        }

        @Override
        public String toString() {
            return String.format("z\t%d", getId());
        }
        public Exception exception = null;
    }

    public static void main(String[] args) {
        try {
            TancSoStudentite environment = new TancSoStudentite();
            environment.start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void start() throws Exception {
        show = new Show();
        init();
        HashSet<Thread> threads = new HashSet<Thread>();
        for (int i = 0; i < BROJ_INSTANCI; i++) {
            Zensko z = new Zensko();
            Masko m = new Masko();
            threads.add(z);
            threads.add(m);
        }

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

        boolean valid = true;
        for (Thread t : threads) {
            if (!hasException) {
                t.join();
            } else {
                t.interrupt();
            }
        }
        show.printStatus();

    }

    public class Show {

        public static final int BROJ_GARDEROBA = 10;
        public static final int BROJ_TEREN = 3;
        public static final int TYPE_MASKO = 1;
        public static final int TYPE_ZENSKO = 2;
        public static final int TYPE_UNKNOWN = -1;

        public Show() {
        }
        public int brojMaskiGarderoba = 0;
        public int brojZenskiGarderoba = 0;
        public int brojTancuvanja = 0;
        public int maxMaskiGarderoba = 0;
        public int maxZenskiGarderoba = 0;
        public int maxTancuvanja = 0;

        public void presobleci() throws RuntimeException {
            log(null, "presobleci start");
            Thread t = Thread.currentThread();
            if (t instanceof Masko) {
                synchronized (RANDOM) {
                    brojMaskiGarderoba++;
                    if (brojMaskiGarderoba > 10) {
                        exception("Ne moze da ima poveke od 10 maski vo maskata garderoba.");
                    }
                    if (brojMaskiGarderoba > maxMaskiGarderoba) {
                        maxMaskiGarderoba = brojMaskiGarderoba;
                    }
                }
                waitRandom();
                synchronized (RANDOM) {
                    brojMaskiGarderoba--;
                }
            } else {
                synchronized (RANDOM) {
                    brojZenskiGarderoba++;
                    if (brojZenskiGarderoba > 10) {
                        exception("Ne moze da ima poveke od 10 zenski vo zenskata garderoba.");
                    }
                    if (brojZenskiGarderoba > maxZenskiGarderoba) {
                        maxZenskiGarderoba = brojZenskiGarderoba;
                    }
                }
                waitRandom();
                synchronized (RANDOM) {
                    brojZenskiGarderoba--;
                }
            }
            log(null, "presobleci kraj");
        }

        public void tancuvaj() throws RuntimeException {
            log(null, "tancuvaj start");
            synchronized (RANDOM) {
                brojTancuvanja++;
                if (brojTancuvanja > BROJ_TEREN) {
                    exception("Ne moze paralelno da tancuvaat poveke od 3 para.");
                }

                if (brojTancuvanja > maxTancuvanja) {
                    maxTancuvanja = brojTancuvanja;
                }
            }
            waitRandom();
            synchronized (RANDOM) {
                brojTancuvanja--;
            }
            log(null, "tancuvaj kraj");
        }

        private void waitRandom() {
            try {
                int r;
                synchronized (RANDOM) {
                    r = RANDOM.nextInt(RANDOM_RANGE);
                }
                Thread.sleep(r);
            } catch (Exception e) {
                //do nothing
            }
        }

        private void exception(String message) {
            RuntimeException e = new RuntimeException(message);
            log(e, null);
            hasError = true;
            throw e;
        }

        public int getType() {
            Thread t = Thread.currentThread();
            if (t instanceof Masko) {
                return TYPE_MASKO;
            } else if (t instanceof Zensko) {
                return TYPE_ZENSKO;
            } else {
                return TYPE_UNKNOWN;
            }
        }

        private synchronized void log(RuntimeException e, String action) {
            Thread t = Thread.currentThread();
            if (e == null) {
                actions.add(t.toString() + "\t(a): " + action);
            } else {
                actions.add(t.toString() + "\t(e): " + e.getMessage());
            }
        }

        public synchronized void printLog() {
            System.out.println("Poradi konkurentnosta za pristap za pecatenje, mozno e nekoja od porakite da ne e na soodvetnoto mesto.");
            System.out.println("Log na izvrsuvanje na akciite:");
            System.out.println("=========================");
            System.out.println("(tip m<=>Masko, tip z<=>Zensko)");
            System.out.println("tip\tid\takcija/error");
            System.out.println("=========================");
            for (String l : actions) {
                System.out.println(l);
            }
        }

        public void printStatus() {
            if (!hasError) {
                int poeni = 25;
                System.out.println("Procesot e uspesno sinhroniziran");
                if (show.maxMaskiGarderoba == 1 || show.maxZenskiGarderoba == 1) {
                    System.out.println("\t-no ima maksimum eden ucesnik vo garderobata.");
                    poeni -= 5;
                }
                if (show.maxTancuvanja == 1) {
                    System.out.println("\t-no ima maksimum edna proverka vo eden moment.");
                    poeni -= 5;
                }

                System.out.println("Osvoeni poeni: " + poeni);

            } else {
                System.out.println("Procesot ne e sinhroniziran spored uslovite na zadacata");
                show.printLog();
                System.out.println("Maksimum mozni poeni: 15");
            }

        }
        private List<String> actions = new ArrayList<String>();
        private boolean hasError = false;
    }
    // Konstanti
    public static int BROJ_INSTANCI = 1000;
    public static final Random RANDOM = new Random();
    public static final int RANDOM_RANGE = 3;
    // Instanca od bafferot
    public Show show;
    public boolean hasException = false;
}






/*
Task 2 Problem 1 (1 / 1)
You need to synchronize the scenario of a barber shop. The barber shop has only one barber who sleeps until there are 5 clients waiting. After 5 clients are present, the fifth one wakes the barber up and he starts to give them haircuts. Once the barber serves all of the clients which are waiting, he falls asleep, again.

When the barber is awake, he calls one client to enter his barber shop. After the client enters, the hair-cutting begins. Once the client has been served, he pays and leaves the barber shop, allowing the next client to enter. If there is no other client present, the barber will go to sleep. If the barber is sleeping, the clients have to wait until they are 5, and the fifth one should wake the barber up.

In the starter code you have the Barber and Customer classes, which represent the barber and the clients. There is only one Barber instance, which calls the execute() method as many times as there are clients in the scenario. There are multiple Customer instances, which call the execute() method only once.

You task is to implement the execute() methods in the Barber and Customer classes, according to the scenario above.

In your implementation, you can use the following methods which already exist in state:

state.customerArrived()
Represents the arrival of the client in front of the barber shop. It's called by the client, upon his arrival.
state.barberWakeUp()
Represents the waking up of the barber. It is called by the barber, when he wakes up.
If the barber is already awake, the call will throw an exception
state.barberCallCustomer()
Represents the client being called by the barber. The method is called by the barber.
If there is no client which has arrived, the call will throw an exception.
state.customerEntry()
Represents the client entering the barber shop. It is called by the client.
If there is no client present, or there has not been a call by the barber, it will throw an exception.
state.cutHair()
Represents the hair-cutting process by the barber. It's called by the barber.
If there is no client present inside the barber shop, it will throw an exception
state.customerPay()
Represents the payment by the client, as he leaves the barber shop. It's called by the client.
state.barberGoToSleep()
Represents the barber going to sleep, when there are no clients present. It is called by the barber.
If the barber is already asleep or there are no waiting clients, it will throw an exception.
These methods are used for validation the scenario and cannot be changed. They need to be called.

Your task is to implement the methods Barber.execute(), Customer.execute() and init(). In your implementation, you can not add try-catch blocks in them. You should define the necessary semaphores and other variables.

If you have an error, you will get this message:

Procesot ne e sinhroniziran spored uslovite na zadacata // The process in not synchronized according to the conditions in the task

After that you will see the log of actions and errors. Use this log to see what went wrong,

Note: Due to concurrent execution of the logging, it is possible that some of the messages in the log are not in the position they are supposed to be. Therefore, use them only as guideline information, do not base all of the conclusions on them.
*/

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.Semaphore;

public class TemplateNumRunsAndNumInstances {

    /*
    INPUT:
    1
    100
    1
    1
     */

    //TODO: definirajte gi semaforite i ostanatite promenlivi ovde (mora site da se static)
    private static int customersWaiting;
    private static Object customerWaitingLock;
    private static Semaphore enterShop;
    private static Semaphore barberWorking;
    private static Semaphore barberFinishedCutting;
    private static Semaphore clientSit;
    private static Semaphore customerPaid;

    /**
     * Metod koj treba da gi inicijalizira vrednostite na semaforite i
     * ostanatite promenlivi za sinhronizacija.
     *
     *
     * TODO: da se implementira
     *
     */
    public static void init(int numBarbers) {
        customersWaiting = 0;
        customerWaitingLock = new Object();
        enterShop = new Semaphore(0);
        barberWorking = new Semaphore(0);
        barberFinishedCutting = new Semaphore(0);
        clientSit = new Semaphore(0);
        customerPaid = new Semaphore(0);
    }

    static class Barber extends TemplateThread {

        public int barberId;

        public Barber(int numRuns, int barberId) {
            super(numRuns);
            this.barberId = barberId;
        }

        /**
         * Da se implementira odnesuvanjeto na berberot spored baranjeto na
         * zadacata.
         *
         *
         * TODO: da se implementira
         *
         */
        public void execute() throws InterruptedException {
            // koga 5tiot klient ke notificira, berberot treba da se razbudi
            barberWorking.acquire();
            state.barberWakeUp();

            // koga klientot ke pristigne, go vika klientot da vleze
            while(true) {
                state.barberCallCustomer();
                enterShop.release();

                // koga klientot ke vleze, go potstrizuva
                clientSit.acquire();
                state.cutHair();

                barberFinishedCutting.release();
                customerPaid.acquire();
                synchronized(customerWaitingLock) {
                    customersWaiting--;

                    // proveruva dali ima klienti koi cekaat, ako nema, zaspiva
                    if(customersWaiting <= 0) {
                        state.barberGoToSleep();
                        barberWorking.acquire();
                    }
                }
            }
        }
    }

    static class Consumer extends TemplateThread {

        public Consumer(int numRuns) {
            super(numRuns);
        }

        /**
         * Da se implementira odnesuvanjeto na ucesnikot spored uslovite na
         * zadacata.
         */
        public void execute() throws InterruptedException {
            synchronized(customerWaitingLock) {
                state.customerArrived();
                customersWaiting++;
                // dokolku e pettiot, go budi berberot
                if(customersWaiting == 5 && !state.barberWaked[0]) {
                    barberWorking.release();
                }
            }
            // koga ke bide povikan, vleguva
            enterShop.acquire();
            state.customerEntry();
            clientSit.release();
            barberFinishedCutting.acquire();
            // klientot vlegol vo berbernicata i e spremen za potstrizuvanje
            // koga ke go potstrizat, plakja
            state.customerPay();
            customerPaid.release();
        }
    }
    //<editor-fold defaultstate="collapsed" desc="This is the template code" >
    static State state;

    static class State {

        private static final Random RANDOM = new Random();
        private static final int RANDOM_RANGE = 5;
        private final int numBarbers;
        private boolean barberWaked[];

        public State(int numBarbers) {
            this.numBarbers = numBarbers;
            barberWaked = new boolean[numBarbers];
        }
        private int arrivedCustomers = 0;
        private int calledCustomers = 0;
        private int maxCuttings = 0;
        private int numCuttings = 0;

        public synchronized void customerArrived() throws RuntimeException {
            log(null, "customer arrived");
            arrivedCustomers++;
        }

        public synchronized void barberWakeUp() {
            Barber b = (Barber) Thread.currentThread();
            if (barberWaked[b.barberId]) {
                PointsException e = new PointsException(5, "Berberot e veke buden i nema potreba da se razbudi.");
                log(e, null);
            } else {
                log(null, "the barber is waked up");
                barberWaked[b.barberId] = true;
            }
        }

        public synchronized void barberCallCustomer() throws RuntimeException {
            log(null, "the barber calls the customer");
            if (arrivedCustomers <= 0) {
                PointsException e = new PointsException(5, "Brojot na klienti koi cekaat e 0 i nema koj da bide povikan.");
                log(e, null);
            }
            calledCustomers++;
        }

        public synchronized void customerEntry() throws RuntimeException {
            log(null, "customer sits in the chair");
            if (arrivedCustomers <= 0) {
                PointsException e = new PointsException(5, "Brojot na klienti koi cekaat e 0 i nema koj da vleze.");
                log(e, null);
            }
            if (calledCustomers <= 0) {
                PointsException e = new PointsException(5, "Nema povikano klient i ne moze da vleze.");
                log(e, null);
            }
            arrivedCustomers--;
            calledCustomers--;

            numCuttings++;
        }

        public void cutHair() throws RuntimeException {
            synchronized (this) {
                if (numCuttings <= 0) {
                    PointsException e = new PointsException(5, "Nema prisuten klient za potstrizuvanje");
                    log(e, null);
                }

                log(null, "berber cuts the customer hair");
            }
            try {
                int r;
                synchronized (this) {
                    r = RANDOM.nextInt(RANDOM_RANGE);
                }
                Thread.sleep(r);
            } catch (Exception e) {
                //do nothing
            }
            synchronized (this) {
                if (numCuttings <= 0) {
                    PointsException e = new PointsException(5, "Brojot na klienti koi se strizat e 0 i nema koj da izleze.");
                    log(e, null);
                }
                numCuttings--;
            }

        }

        public synchronized void customerPay() throws RuntimeException {
            log(null, "customer is paying and leaving the shop");


        }

        public synchronized void barberGoToSleep() throws RuntimeException {
            Barber b = (Barber) Thread.currentThread();
            if (!barberWaked[b.barberId]) {
                PointsException e = new PointsException(5, "Berberite veke spijat i ne moze da se prezaspijat.");
                log(e, null);
            }
            if (arrivedCustomers > 0) {
                PointsException e = new PointsException(5, "Seuste ima klienti koi cekaat i berberot ne moze da odi na spienje.");
                log(e, null);
            }
            log(null, "all barbers go to sleap");
            barberWaked[b.barberId] = false;
        }
        private List<String> actions = new ArrayList<String>();
        private List<PointsException> exceptions = new ArrayList<PointsException>();

        private synchronized void log(PointsException e, String action) {
            TemplateThread t = (TemplateThread) Thread.currentThread();
            if (e == null) {
                actions.add(t.toString() + "\t(a): " + action);
            } else {
                t.setException(e);
                actions.add(t.toString() + "\t(e): " + e.getMessage());
            }
        }

        public synchronized void printLog() {
            System.out.println("Poradi konkurentnosta za pristap za pecatenje, mozno e nekoja od porakite da ne e na soodvetnoto mesto.");
            System.out.println("Log na izvrsuvanje na akciite:");
            System.out.println("=========================");
            System.out.println("tip\tid\titer\takcija/error");
            System.out.println("=========================");
            for (String l : actions) {
                System.out.println(l);
            }
        }

        public void printStatus() {
            if (!TemplateThread.hasException) {
                int poeni = 25;
                if (PointsException.getTotalPoints() == 0) {
                    System.out.println("Procesot e uspesno sinhroniziran. Osvoeni 25 poeni.");
                } else {
                    poeni -= PointsException.getTotalPoints();
                    PointsException.printErrors();
                    System.out.println("Osvoeni poeni: " + poeni);
                }

            } else {
                System.out.println("Procesot ne e sinhroniziran spored uslovite na zadacata");
                printLog();
                System.out.println("====================================================");
                PointsException.printErrors();
                System.out.println("Maksimum Poeni: " + (25 - PointsException.getTotalPoints()));
            }

        }
    }

    abstract static class TemplateThread extends Thread {

        static boolean hasException = false;
        int numRuns = 1;
        public int iteration = 0;
        private Exception exception = null;

        public TemplateThread(int numRuns) {
            this.numRuns = numRuns;
        }

        abstract void execute() throws InterruptedException;

        @Override
        public void run() {
            try {
                for (int i = 0; i < numRuns && !hasException; i++) {
                    execute();
                    iteration++;

                }
            } catch (InterruptedException e) {
                // Do nothing
            } catch (Exception e) {
                exception = e;
                hasException = true;
            }
        }

        public void setException(Exception exception) {
            this.exception = exception;
            hasException = true;
        }

        @Override
        public String toString() {
            Thread current = Thread.currentThread();
            if (numRuns > 1) {
                return String.format("%s\t%d\t%d", "" + current.getClass().getSimpleName().charAt(0), getId(), iteration);
            } else {
                return String.format("%s\t%d\t", "" + current.getClass().getSimpleName().charAt(0), getId());
            }
        }
    }

    static class PointsException extends RuntimeException {

        private static HashMap<String, PointsException> exceptions = new HashMap<String, PointsException>();
        private int points;

        public PointsException(int points, String message) {
            super(message);
            this.points = points;
            exceptions.put(message, this);
        }

        public static int getTotalPoints() {
            int sum = 0;
            for (PointsException e : exceptions.values()) {
                sum += e.getPoints();
            }
            return sum;
        }

        public static void printErrors() {
            System.out.println("Gi imate slednite greski: ");
            for (Map.Entry<String, PointsException> e : exceptions.entrySet()) {
                System.out.println(String.format("[%s] : (-%d)", e.getKey(), e.getValue().getPoints()));
            }
        }

        public int getPoints() {
            return points;
        }
    }

    public static void main(String[] args) {
        try {
            start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void start() throws Exception {
        Scanner s = new Scanner(System.in);
        int brBarbers = s.nextInt();
        int brKonzumeri = s.nextInt();
        int numBarberRuns = s.nextInt();
        int numCustomerRuns = s.nextInt();
        init(brBarbers);

        state = new State(brBarbers);
        HashSet<Thread> threads = new HashSet<Thread>();

        for (int i = 0; i < brBarbers; i++) {
            Barber prod = new Barber(numBarberRuns, i);
            threads.add(prod);
            prod.start();
            Consumer c = new Consumer(numCustomerRuns);
            threads.add(c);
            c.start();
        }

        for (int i = 0; i < brKonzumeri / 2 - brBarbers; i++) {
            Consumer c = new Consumer(numCustomerRuns);
            threads.add(c);
            c.start();
        }
        try {
            Thread.sleep(50);
        } catch (Exception e) {
            //do nothing
        }
        for (int i = 0; i < brKonzumeri / 2; i++) {
            Consumer c = new Consumer(numCustomerRuns);
            threads.add(c);
            c.start();
        }


        for (Thread t : threads) {
            t.join(1000);
        }

        for (Thread t : threads) {
            if (t.isAlive()) {
                t.interrupt();
            }
        }

        state.printStatus();
    }
    //</editor-fold>
}





/*
Task 3 Problem 1 (1 / 1)
A tribe is eating a dinner prepared in a large kettle which holds a limited number of portions. Each tribe member takes a portion on his own, if there is food in the kettle. If the kettle is empty, the cooking chef is called to prepare a new kettle full of food. Only one tribe member can check if the kettle is empty at a given moment. However, there are three places around the kettle, meaning three tribe members can take food in parallel. The number of member eating concurrently is not limited.

The kettle is empty initially.

Your task is to synchronize the given scenario.

In the starter code, you have a definition of the TribeMember class, which represents the tribe members and their behavior. There are multiple instances of TribeMember in which the execute() method is called multiple times.

In your implementation you can use the following methods from state:

state.isPotEmpty()
Used to check if there is still food in the kettle. It manipulates with a global variable and should be treated as a critical region.
If more than one tribe member checks at the same time, the call will throw an exception.
state.fillPlate()
Represents taking food from the kettle.
If the kettle is empty, or more then 3 tribe member all it in parallel, it will throw an exception
state.eat()
Represents the consuming of food by the tribe member.
state.cook()
Represents the cooking done by the cooking chef.
If the kettle is not empty, it will throw an exception.
These methods are used for validation the scenario and cannot be changed. They need to be called.

Your task is to implement the methods TribeMember.execute() and init(). In your implementation, you can not add try-catch blocks in them. You should define the necessary semaphores and other variables.

If you have an error, you will get this message:

Procesot ne e sinhroniziran spored uslovite na zadacata // The process in not synchronized according to the conditions in the task

After that you will see the log of actions and errors. Use this log to see what went wrong,

Note: Due to concurrent execution of the logging, it is possible that some of the messages in the log are not in the position they are supposed to be. Therefore, use them only as guideline information, do not base all of the conclusions on them.
*/

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

public class TribeDinner {

    // TODO: definirajte gi semaforite i ostanatite promenlivi ovde (mora site da se static)
    private static Semaphore kettleAccess;
    private static Object checkKettle;

    /**
     * Metod koj treba da gi inicijalizira vrednostite na semaforite i
     * ostanatite promenlivi za sinhronizacija.
     *
     *
     * TODO: da se implementira
     *
     */
    public static void init(int numBarbers) {
        kettleAccess = new Semaphore(3);
        checkKettle = new Object();
    }

    static class TribeMember extends TemplateThread {

        public TribeMember(int numRuns) {
            super(numRuns);
        }

        /**
         * Da se implementira odnesuvanjeto na ucesnikot spored uslovite na
         * zadacata.
         */
        public void execute() throws InterruptedException {
            kettleAccess.acquire();
            synchronized(checkKettle) {
                if(state.isPotEmpty()) {
                    state.cook();
                }
            }
            state.fillPlate(); // 3 can fill plates
            kettleAccess.release();

            state.eat(); // not limited
        }
    }

    // <editor-fold defaultstate="collapsed" desc="This is the template code" >
    static State state;

    static class State {

        private static final String _10_JADENJETO_NE_E_PARALELIZIRANO = "jadenjeto ne e paralelizirano. Site jadat eden po eden";
        private static final String _10_PRISTAPOT_DO_KAZANOT_NE_E_PARALELIZIRAN = "Pristapot do kazanot ne e paraleliziran. Treda da moze do trojca paralelno da zemaat hrana.";

        private static final String _10_DVAJCA_ISTOVREMENO_PROVERUVAAT = "Dvajca istovremeno proveruvaat dali kazanot e prazen. Maksimum eden e dozvoleno.";
        private static final String _7_NEMA_MESTO_POKRAJ_KAZANOT = "Nema mesto pokraj kazanot. Maksimum tri clena moze da zemaat hrana istovremeno.";
        private static final String _5_NE_MOZE_DA_JADE_OD_PRAZEN_KAZAN = "Ne moze da jade od prazen kazan. Treba da se povika 'state.cook()'";
        private static final String _5_NE_MOZE_DA_SE_GOTVI_VO_KAZAN_KOJ_NE_E_PRAZEN = "Ne moze da se gotvi vo kazan koj ne e prazen";

        private static final Random RANDOM = new Random();
        private static final int POT_CAPACITY = 15;

        private LimitedCounter platesLeft = new LimitedCounter(0, null, 0,
                null, 0, 5, _5_NE_MOZE_DA_JADE_OD_PRAZEN_KAZAN);

        private LimitedCounter checks = new LimitedCounter(0, 1, 10,
                _10_DVAJCA_ISTOVREMENO_PROVERUVAAT, null, 0, null);

        private LimitedCounter fills = new LimitedCounter(0, 3, 7,
                _7_NEMA_MESTO_POKRAJ_KAZANOT, null, 0, null);

        private LimitedCounter eat = new LimitedCounter(0);

        public State() {

        }

        public boolean isPotEmpty() throws RuntimeException {
            log(checks.incrementWithMax(), "proverka dali ima hrana vo kazanot");
            sleep(5);
            boolean res = platesLeft.getValue() == 0;
            log(checks.decrementWithMin(), null);
            return res;
        }

        public void fillPlate() throws RuntimeException {
            log(fills.incrementWithMax(), "zemanje na hrana");
            log(platesLeft.decrementWithMin(), null);
            sleep(5);
            log(platesLeft.incrementWithMax(), null);
            log(fills.decrementWithMin(), null);
        }

        public void eat() throws RuntimeException {
            log(eat.incrementWithMax(), "jadenje");
            sleep(10);
            log(eat.decrementWithMin(), null);
        }

        public void cook() throws RuntimeException {
            synchronized (State.class) {
                if (platesLeft.getValue() == 0) {
                    platesLeft.setValue(POT_CAPACITY);
                } else {
                    PointsException e = new PointsException(5,
                            _5_NE_MOZE_DA_SE_GOTVI_VO_KAZAN_KOJ_NE_E_PRAZEN);
                    log(e, null);
                }
            }
        }

        public void finalize() {
            if (fills.getMax() == 1) {
                logException(new PointsException(10,
                        _10_PRISTAPOT_DO_KAZANOT_NE_E_PARALELIZIRAN));
            }
            if (eat.getMax() == 1) {
                logException(new PointsException(10,
                        _10_JADENJETO_NE_E_PARALELIZIRANO));
            }
        }

        private List<String> actions = new ArrayList<String>();

        private void sleep(int range) {
            try {
                Thread.sleep(RANDOM.nextInt(range));
            } catch (InterruptedException e) {
            }
        }

        protected TemplateThread getThread() {
            TemplateThread t = (TemplateThread) Thread.currentThread();
            return t;
        }

        private synchronized void log(PointsException e, String action) {
            TemplateThread t = (TemplateThread) Thread.currentThread();
            if (e != null) {
                t.setException(e);
                actions.add(t.toString() + "\t(e): " + e.getMessage());
            } else if (action != null) {
                actions.add(t.toString() + "\t(a): " + action);
            }
        }

        private synchronized void logException(PointsException e) {
            actions.add("\t(e): " + e.getMessage());
        }

        public synchronized void printLog() {
            System.out
                    .println("Poradi konkurentnosta za pristap za pecatenje, mozno e nekoja od porakite da ne e na soodvetnoto mesto.");
            System.out.println("Log na izvrsuvanje na akciite:");
            System.out.println("=========================");
            System.out.println("tip\tid\titer\takcija/error");
            System.out.println("=========================");
            for (String l : actions) {
                System.out.println(l);
            }
        }

        public void printStatus() {
            finalize();
            if (!TemplateThread.hasException) {
                int poeni = 25;
                if (PointsException.getTotalPoints() == 0) {
                    System.out
                            .println("Procesot e uspesno sinhroniziran. Osvoeni 25 poeni.");
                } else {
                    poeni -= PointsException.getTotalPoints();
                    PointsException.printErrors();
                    System.out.println("Maksimalni osvoeni poeni: " + poeni);
                }

            } else {
                System.out
                        .println("Procesot ne e sinhroniziran spored uslovite na zadacata");
                printLog();
                System.out
                        .println("====================================================");
                PointsException.printErrors();
                int total = (25 - PointsException.getTotalPoints());
                if (total < 0) {
                    total = 0;
                }
                System.out.println("Maksimum Poeni: " + total);
            }

        }
    }

    static class LimitedCounter {

        private int value;
        private Integer maxAllowed;
        private Integer minAllowed;
        private int maxErrorPoints;
        private int minErrorPoints;
        private String maxErrorMessage;
        private String minErrorMessage;

        private int max;

        public LimitedCounter(int value) {
            super();
            this.value = value;
            this.max = value;
        }

        public LimitedCounter(int value, Integer maxAllowed,
                              int maxErrorPoints, String maxErrorMessage, Integer minAllowed,
                              int minErrorPoints, String minErrorMessage) {
            super();
            this.value = value;
            this.max = value;
            this.maxAllowed = maxAllowed;
            this.minAllowed = minAllowed;
            this.maxErrorPoints = maxErrorPoints;
            this.minErrorPoints = minErrorPoints;
            this.maxErrorMessage = maxErrorMessage;
            this.minErrorMessage = minErrorMessage;
        }

        public int getMax() {
            return max;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public PointsException incrementWithMax() {
            synchronized (LimitedCounter.class) {
                value++;
                if (value > max) {
                    max = value;
                }
                if (maxAllowed != null) {
                    if (value > maxAllowed) {
                        PointsException e = new PointsException(maxErrorPoints,
                                maxErrorMessage);
                        return e;
                    }
                }
            }
            return null;
        }

        public PointsException decrementWithMin() {
            synchronized (LimitedCounter.class) {
                value--;
                if (minAllowed != null) {
                    if (value < minAllowed) {
                        PointsException e = new PointsException(minErrorPoints,
                                minErrorMessage);
                        return e;
                    }
                }
            }
            return null;
        }
    }

    abstract static class TemplateThread extends Thread {

        static boolean hasException = false;
        int numRuns = 1;
        public int iteration = 0;
        protected Exception exception = null;

        public TemplateThread(int numRuns) {
            this.numRuns = numRuns;
        }

        abstract void execute() throws InterruptedException;

        @Override
        public void run() {
            try {
                for (int i = 0; i < numRuns && !hasException; i++) {
                    execute();
                    iteration++;

                }
            } catch (InterruptedException e) {
                // Do nothing
            } catch (Exception e) {
                exception = e;
                hasException = true;
            }
        }

        public void setException(Exception exception) {
            this.exception = exception;
            hasException = true;
        }

        @Override
        public String toString() {
            Thread current = Thread.currentThread();
            if (numRuns > 1) {
                return String.format("%s\t%d\t%d", ""
                                + current.getClass().getSimpleName().charAt(0),
                        getId(), iteration);
            } else {
                return String
                        .format("%s\t%d\t", ""
                                        + current.getClass().getSimpleName().charAt(0),
                                getId());
            }
        }
    }

    static class PointsException extends RuntimeException {

        private static HashMap<String, PointsException> exceptions = new HashMap<String, PointsException>();
        private int points;

        public PointsException(int points, String message) {
            super(message);
            this.points = points;
            exceptions.put(message, this);
        }

        public static int getTotalPoints() {
            int sum = 0;
            for (PointsException e : exceptions.values()) {
                sum += e.getPoints();
            }
            return sum;
        }

        public static void printErrors() {
            System.out.println("Gi imate slednite greski: ");
            for (Map.Entry<String, PointsException> e : exceptions.entrySet()) {
                System.out.println(String.format("[%s] : (-%d)", e.getKey(), e
                        .getValue().getPoints()));
            }
        }

        public int getPoints() {
            return points;
        }
    }

    public static void main(String[] args) {
        try {
            start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void start() throws Exception {
        Scanner s = new Scanner(System.in);
        int brKonzumeri = s.nextInt();
        int numCustomerRuns = s.nextInt();
        init(brKonzumeri);

        state = new State();
        HashSet<Thread> threads = new HashSet<Thread>();

        for (int i = 0; i < brKonzumeri; i++) {
            TribeMember c = new TribeMember(numCustomerRuns);
            threads.add(c);
            c.start();
        }
        try {
            Thread.sleep(50);
        } catch (Exception e) {
            // do nothing
        }

        for (Thread t : threads) {
            t.join(1000);
        }

        for (Thread t : threads) {
            if (t.isAlive()) {
                t.interrupt();
                if (t instanceof TemplateThread) {
                    TemplateThread tt = (TemplateThread) t;
                    tt.setException(new PointsException(25, "DEADLOCK"));
                }
            }
        }
        s.close();
        state.printStatus();
    }
    // </editor-fold>
}






/*
Task 4 Problem 1 (1 / 1)
Implement a mini voting system. In the beginning, all the candidates are saved at the server side, along with their respective numbers (ex. Petar Kostandinov - 1, Ilija Petkovski - 2 etc). The client, after connecting to the server, should receive the entire voting list and choose the desired candidate, by sending the candidate number to the server. Any client can, at any time, get the results for each candidate. The server allows maximum 100 clients connected at the same moment.

Note: Define the communication protocol - define the set of states and the format of the messages that are to be sent.
*/

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.concurrent.Semaphore;

public class TCPVotingSystemServer {
    ServerSocket server;
    HashMap<Integer, Candidate> candidates;
    HashMap<Integer, Socket> connections;
    Semaphore maxClients;

    public static final String ANSI_GREEN = "\u001B[32m";
    public static final String ANSI_YELLOW = "\u001B[33m";
    public static final String ANSI_BLUE = "\u001B[34m";
    public static final String ANSI_PURPLE = "\u001B[35m";
    public static final String ANSI_CYAN = "\u001B[36m";
    public static final String ANSI_WHITE = "\u001B[37m";

    public TCPVotingSystemServer(Integer port) {
        try {
            this.server = new ServerSocket(port);
            candidates = new HashMap<>();
            connections = new HashMap<>(1000);
            this.maxClients = new Semaphore(100);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void addNewCandidate(int number, String name) {
        candidates.put(number, new Candidate(name, number));
    }

    public void addNewConnection(int id, Socket connection) {
        connections.put(id, connection);
    }

    public void removeConnection(int id) {
        connections.remove(id);
        maxClients.release();
    }

    public void listen() throws IOException, InterruptedException {
        while(true) {
            maxClients.acquire();

            // Accept incoming connection
            Socket newClient = server.accept();

            // Create input and output streams
            DataInputStream br = new DataInputStream(newClient.getInputStream());
            DataOutputStream bw = new DataOutputStream(newClient.getOutputStream());

            ServerWorkerThread newConnection = new ServerWorkerThread(this, newClient, br, bw);
            newConnection.start();
        }
    }

    public static void main(String[] args) {
        try {
            int noCandidates;
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            TCPVotingSystemServer server = new TCPVotingSystemServer(9000);
            System.out.println(ANSI_GREEN + "Server successfully created (Port: 9000)");
            System.out.println(ANSI_BLUE + "---------------- ( SETUP ) ----------------");
            System.out.print("Insert number of candidates: ");
            noCandidates = Integer.parseInt(br.readLine());
            for (int i = 0; i < noCandidates; i++) {
                System.out.print(ANSI_BLUE + "(Candidate: " + i+1 + ") Number: ");
                int number = Integer.parseInt(br.readLine());
                System.out.print(ANSI_BLUE + "(Candidate: " + i+1 + ") Name: ");
                String name = br.readLine();
                server.addNewCandidate(number, name);
            }
            System.out.println(ANSI_BLUE + "------------ ( SETUP FINISHED ) ------------");

            server.listen();
        } catch(Exception e) {
            System.err.println("ERROR: Something went wrong!");
        }
    }
}

class ServerWorkerThread extends Thread {
    TCPVotingSystemServer server;
    Socket client;
    DataInputStream in;
    DataOutputStream out;
    Integer connectionId;

    public static final String ANSI_GREEN = "\u001B[32m";
    public static final String ANSI_YELLOW = "\u001B[33m";
    public static final String ANSI_BLUE = "\u001B[34m";
    public static final String ANSI_PURPLE = "\u001B[35m";
    public static final String ANSI_CYAN = "\u001B[36m";
    public static final String ANSI_WHITE = "\u001B[37m";

    ServerWorkerThread(TCPVotingSystemServer server, Socket client, DataInputStream in, DataOutputStream out) {
        this.server = server;
        this.client = client;
        this.in = in;
        this.out = out;
        this.connectionId = null;
    }

    public void listen() throws IOException {
        while(true) {
            if(client.isClosed()) break;
            String recievedCommand;
            recievedCommand = in.readUTF().trim();
            if(recievedCommand.equals("CloseConnection")) {
                out.writeUTF("(Client ID: " + connectionId + ") Connection successfully closed");
                out.flush();
                server.removeConnection(connectionId);
                client.close();
                continue;
            } else if(recievedCommand.contains("Vote")) {
                String parts[] = recievedCommand.split("\\s");
                Candidate c = server.candidates.get(Integer.parseInt(parts[1]));
                if(c != null) {
                    c.addVote();
                    out.writeUTF("(Client ID: " + connectionId + ") Successfully voted!");
                    out.flush();
                } else {
                    out.writeUTF("Invalid client id!");
                    out.flush();
                }
            } else if(recievedCommand.contains("GetList")) {
                StringBuilder sb = new StringBuilder();
                sb.append("--------------- (VOTE LIST) ---------------\n");
                for(Candidate c : server.candidates.values()) {
                    sb.append(c + "\n");
                }
                sb.append("--------------- (VOTE LIST) ---------------\n");
                out.writeUTF(sb.toString());
                out.flush();
            } else {
                out.writeUTF("Invalid command");
                out.flush();
            }
        }
    }

    @Override
    public void run() {
        try {
            this.connectionId = in.readInt();
            server.addNewConnection(connectionId, client);

            System.out.println(ANSI_PURPLE + "SERVER: " + ANSI_WHITE + "New client arrived (ID: " + connectionId + ")");
            listen();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Candidate {
    String name;
    int number;
    int votes;

    public Candidate(String name, int number) {
        this.name = name;
        this.number = number;
        this.votes = 0;
    }

    public void addVote() {
        votes++;
    }

    @Override
    public String toString() {
        return String.format("Candidate: %s (%d) | Votes: %d", name, number, votes);
    }
}



import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.HashSet;
import java.util.Random;

public class TCPVotingSystemClient {

    private static final String ANSI_GREEN = "\u001B[32m";
    private static final String ANSI_YELLOW = "\u001B[33m";
    private static final String ANSI_BLUE = "\u001B[34m";
    private static final String ANSI_PURPLE = "\u001B[35m";
    private static final String ANSI_CYAN = "\u001B[36m";
    private static final String ANSI_WHITE = "\u001B[37m";

    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            HashSet<ClientWorkerThread> clients = new HashSet<>(1000);

            for(int i=0; i<1000; i++) {
                clients.add(new ClientWorkerThread(i, false));
            }

            clients.forEach(Thread::start);

            new ClientWorkerThread(0, true).start();
        } catch(Exception e) {
            e.printStackTrace();
            System.err.println("ERROR: Something went wrong!");
        }
    }
}

class ClientWorkerThread extends Thread {
    private Socket connection;
    private DataInputStream in;
    private DataOutputStream out;
    private Integer id;

    private static final String ANSI_GREEN = "\u001B[32m";
    private static final String ANSI_YELLOW = "\u001B[33m";
    private static final String ANSI_BLUE = "\u001B[34m";
    private static final String ANSI_PURPLE = "\u001B[35m";
    private static final String ANSI_CYAN = "\u001B[36m";
    private static final String ANSI_WHITE = "\u001B[37m";

    public ClientWorkerThread(int id, boolean test) {
        if(test == true) this.id = 1212121;
        else this.id = id;
    }

    private void sendClientID(int id) throws IOException {
        out.writeInt(id);
        out.flush();
    }

    public void sendCommand(String command) throws IOException {
        try {
            out.writeUTF(command);
            out.flush();
            System.out.println(ANSI_YELLOW + in.readUTF());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public synchronized void start() {
        try {
            this.connection = new Socket(InetAddress.getByName("localhost"), 9000);
            this.in = new DataInputStream(connection.getInputStream());
            this.out = new DataOutputStream(connection.getOutputStream());

            sendClientID(id);

            Random r = new Random();
            sendCommand("Vote " + (r.nextInt(2)+1));
            if(this.id == 1212121) sendCommand("GetList");
            sendCommand("CloseConnection");
        } catch (IOException e) {
            e.printStackTrace();
        }
//        System.out.println(ANSI_BLUE + "---------------- ( Available commands ) ----------------");
//        System.out.println(ANSI_PURPLE + "GetList " + ANSI_BLUE + "// get the list with the candidates and their current votes.");
//        System.out.println(ANSI_PURPLE + "Vote number " + ANSI_BLUE + "// Vote for some candidate.");
//        System.out.println(ANSI_PURPLE + "CloseConnection " + ANSI_BLUE + "// Closes the connection.");
//        System.out.println(ANSI_BLUE + "Type the commands in the following format ClientID: Command ");
//        System.out.println(ANSI_BLUE + "Example:" + ANSI_CYAN + " 1: GetList");
//        System.out.println(ANSI_BLUE + "---------------- ( Available commands ) ----------------");
    }
}