SJF

/////////////////////////////////// MAIN //////////////////////////////////////////
import CPU.*;
import Localization.English;
import Localization.Locale;
import Localization.Polish;

import java.awt.image.AreaAveragingScaleFilter;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Main {

    private static int procesorInc = 1;

    public static CPU createCPU(Random generator, Locale jezyk, CPUResources zasoby) {
        return new CPU(procesorInc++, generator.nextInt(5)/ (1 + generator.nextInt(3)), jezyk,zasoby );
    }

    public static void wykonuj(List<Task> taski, List<CPU> procesory) throws DeadlineException {
        int i = 0;
        for (Task zadanie : taski) {
            if(i == procesory.size())
                i = 0;
            procesory.get(i).dodaj(zadanie);
            ++i;
        }

        for(CPU cpu : procesory) {
            while (cpu.saZadania()) {
                cpu.wykonajJedno();
            }
        }
    }

    public static List<Task> generateTasks(Random generator) {
        List<Task> taski = new ArrayList<Task>();
        int size = 5 + generator.nextInt(5);
        for (int nr = 1; nr <= size; ++nr) {
            double czasStart = generator.nextInt(20);
            double deadline = 10 + czasStart + generator.nextInt(30);
            taski.add(new Task(nr, czasStart, deadline,generator.nextInt(20)));
        }
        return taski;
    }

    public static void main(String[] args) {
        Random generator = new Random();

        Locale jezyk = new Polish();
        // lub:
        // Locale jezyk = new English();

        CPUResources zasoby = new CPUResources(jezyk,generator.nextInt(250));
        System.out.println(jezyk.get("RESOURCES_NUMBER") + ": " + zasoby.getRozmiar());

        List<CPU> procesory = new ArrayList<CPU>();
        procesory.add(createCPU(generator,jezyk,zasoby));

        List<Task> taski = generateTasks(generator);

        boolean notFinished = true;
        while (notFinished) {
            try {
                wykonuj(taski, procesory);
                notFinished = false;
            } catch (DeadlineException e) {
                System.out.println(e.getMessage() + " | " + e.getZadanie().getNumer());
                procesory.add(createCPU(generator, jezyk, zasoby));
                for(CPU p : procesory) {
                    p.clear();
                }
                notFinished = true;
            } finally {
                // test
                if(procesory.size() >= 5) {
                    break;
                }
            }
        }
    }
}

////////////////////////////////////////// PACKAGE LOCALIZATION ///////////////////////////////////////////
////////////////////////////////////////// BASE //////////////////////////////////////////////////////////
package Localization;

import java.util.Map;

abstract public class Base implements Locale {

    private String name;
    private Map<String, String> map;

    public Base(String name) {
        this.name = name;
        this.map = this.createMap();
    }

    @Override
    public String get(String key) {
        return this.map.containsKey(key) ? this.map.get(key) : key;
    }

    @Override
    public String getName() {
        return name;
    }

    /**
     * @return Zwraca mape z unikalnymi kluczami, i z odpowiednimi dla jezyka wartosciami
     */
    abstract protected Map<String, String> createMap();
}
  ////////////////////////////////////////////////// ENGLISH /////////////////////////////////////////////////
package Localization;

import java.util.HashMap;
import java.util.Map;

/**
 * W tym miejscu jest polimorfizm
 */
public class English extends Base {

    public English() {
        super("English");
    }

    @Override
    protected Map<String, String> createMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("LOCALE_NAME","Language name");
        map.put("RESOURCES_NUMBER","Number of resources");
        map.put("ERROR_DEADLINE", "[Error] Exceeded deadline time.");
        map.put("ERROR_LACK_OF_RESOURCES", "[Error] Lack of resources");
        map.put("ADDED_RESOURCES", "Added resources");
        map.put("ADDED_TASK", "Added (test/resources): ");
        map.put("EXECUTED","Executed: stratTime | realStart | End | Deadline");
        map.put("EXECUTED_TASK", "- [Task]: ");
        return map;
    }
}

/////////////////////////////////////////////////// LOCALE ///////////////////////////////////////////////////
package Localization;

public interface Locale {

    /**
     * @return nazwa uzywanego jezyka
     */
    public String getName();

    /**
     *
     * @param key unikalna nazwa wartosci jaka chcemy otrzymac
     * @return wartosc w ustawionym jezyku
     */
    public String get(String key);
}

///////////////////////////////////////////////////// POLISH ///////////////////////////////////////////////////////
package Localization;

import java.util.HashMap;
import java.util.Map;

/**
 * W tym miejscu jest polimorfizm
 */
public class Polish extends Base {

    public Polish() {
        super("Polish");
    }

    @Override
    protected Map<String, String> createMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("LOCALE_NAME","Nazwa jezyka");
        map.put("RESOURCES_NUMBER","Ilosc zasobow");
        map.put("ERROR_DEADLINE", "[Blad] Przekroczono czas deadline.");
        map.put("ERROR_LACK_OF_RESOURCES", "[Blad] Brakuje zasobow");
        map.put("ADDED_RESOURCES", "Dodano zasoby");
        map.put("ADDED_TASK", "Dodano(zadanie/zasoby): ");
        map.put("EXECUTED","Wykonano: czasStart | Start | End | Deadline");
        map.put("EXECUTED_TASK", "- [Zadanie]: ");
        return map;
    }
}

/////////////////////////////////////////////////////// PACKAGE CPU //////////////////////////////////////////////////////
/////////////////////////////////////////////////////// CPU //////////////////////////////////////////////////////
package CPU;

import Localization.Locale;

import java.util.PriorityQueue;


public class CPU {

    private int numer;
    private double moc;
    private double czas;
    private Locale jezyk;
    private CPUResources zasoby;
    private PriorityQueue<Task> zadania;

    public CPU(int numer, double moc, Locale jezyk, CPUResources zasoby) {
        this.numer = numer;
        this.moc = moc;
        this.jezyk = jezyk;
        this.zasoby = zasoby;
        this.czas = 0.0;
        this.zadania = new PriorityQueue<Task>();
    }

    private double calcComplex(Task zadanie) {
        return zadanie.getRozmiarZadania() / moc;
    }

    public void dodaj(Task zadanie) {
        try {
            zasoby.zajmij(zadanie.getRozmiarZadania());
            zadania.add(zadanie);
            System.out.println(jezyk.get("ADDED_TASK") + zadanie.getNumer() + "/" + zadanie.getRozmiarZadania());
        } catch (CPUException e) {
            System.out.println(e.getMessage());
            double dodano = zadanie.getRozmiarZadania()-zasoby.getRozmiar();
            zasoby.zwolnij(dodano);
            System.out.println(jezyk.get("ADDED_RESOURCES") + ": " + dodano);
            dodaj(zadanie);
        }
    }

    public void wykonajJedno() throws DeadlineException {
        Task zadanie = zadania.peek();
        if(czas >= zadanie.getCzasStart()) {
            double realStart = this.czas;
            double realEnd = this.czas + calcComplex(zadanie);

            // Przerwij jesli przekroczono deadline
            if(realEnd > zadanie.getDeadline()) {
                throw new DeadlineException(jezyk.get("ERROR_DEADLINE"), realEnd, zadanie);
            }

            System.out.println(jezyk.get("EXECUTED_TASK") + zadanie.getCzasStart() + " | " + realStart + " | " + realEnd + " | " + zadanie.getDeadline());

            // Zwolnienie zasobow
            zasoby.zwolnij(zadanie.getRozmiarZadania());
            zadania.poll();
            this.czas = realEnd;
        } else {
            this.czas += 1.0;
        }
    }

    public Task getPierwszeZadanie() {
        return zadania.peek();
    }

    public void clear() {
        zadania.clear();
        this.czas = 0.0;
    }

    public double getCzas() {
        return czas;
    }

    public boolean saZadania() {
        return !zadania.isEmpty();
    }

    public int iloscZadan() {
        return zadania.size();
    }
}

/////////////////////////////////////////////////////// CPUException//////////////////////////////////////////////////////
package CPU;


public class CPUException extends Exception {
    public CPUException(String message) {
        super(message);
    }
}

/////////////////////////////////////////////////////// CPUResources //////////////////////////////////////////////////////
package CPU;

import Localization.Locale;


public class CPUResources extends Resource {

    private Locale jezyk;

    public CPUResources(Locale jezyk, double rozmiar) {
        super(rozmiar);
        this.jezyk = jezyk;
    }

    public void zajmij(double rozmiar) throws CPUException {
        double pozostalo = this.getRozmiar() - rozmiar;
        if(pozostalo >= 0.0) {
            setRozmiar(pozostalo);
        } else {
            throw new CPUException(jezyk.get("ERROR_LACK_OF_RESOURCES"));
        }
    }

    public void zwolnij(double rozmiar) {
        setRozmiar(this.getRozmiar() + rozmiar);
    }
}

/////////////////////////////////////////////////////// DeadlineException//////////////////////////////////////////////////////
package CPU;

public class DeadlineException extends CPUException {
    private double przewidywanyCzasZakonczenia;
    private Task zadanie;
    public DeadlineException(String message, double przewidywanyCzasZakonczenia, Task zadanie) {
        super(message);
        this.przewidywanyCzasZakonczenia = przewidywanyCzasZakonczenia;
        this.zadanie = zadanie;
    }

    public double getPrzewidywanyCzasZakonczenia() {
        return przewidywanyCzasZakonczenia;
    }

    public Task getZadanie() {
        return zadanie;
    }
}

/////////////////////////////////////////////////////// Resource//////////////////////////////////////////////////////
package CPU;


public class Resource {
    private double rozmiar;

    public Resource(double rozmiar) {
        this.rozmiar = rozmiar;
    }

    public double getRozmiar() {
        return rozmiar;
    }

    public void setRozmiar(double rozmiar) {
        this.rozmiar = rozmiar;
    }
}

/////////////////////////////////////////////////////// Task//////////////////////////////////////////////////////

package CPU;


public class Task implements Comparable<Task> {

    private int numer;
    private Resource zasoby;
    private double czasStart;
    private double deadline;

    public Task(int numer, double czasStart, double deadline, double rozmiar) {
        this.numer = numer;
        this.zasoby = new Resource(rozmiar);
        this.czasStart = czasStart;
        this.deadline = deadline;
    }

    public double getRozmiarZadania() {
        return zasoby.getRozmiar();
    }

    @Override
    public int compareTo(Task o) {
        if(getCzasStart() < o.getCzasStart()) {
            return -1;
        }
        if(getCzasStart() > o.getCzasStart()) {
            return 1;
        }
        if(getCzasStart() == o.getCzasStart()) {
            if(getDeadline() < o.getDeadline()) {
                return -1;
            }
            if(getDeadline() > o.getDeadline()) {
                return 1;
            }
        }
        return 0;
    }

    public double getDeadline() {
        return deadline;
    }

    public double getCzasStart() {
        return czasStart;
    }

    public int getNumer() {
        return numer;
    }
}