SHARE
TWEET

kahut

pain2theworld Sep 21st, 2019 105 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.io.IOException;
  2. import java.util.*;
  3. import java.util.concurrent.Semaphore;
  4.  
  5. //public static void synchronized void *(){}
  6.  
  7. public class SeptemberTribeDinner {
  8.  
  9.     public static Semaphore spremno;
  10.     public static Semaphore trebadasezgotvi;
  11.     public static Semaphore sednijadi;
  12.     public static Semaphore proveriHrana;
  13.  
  14.     public static void init() {
  15.  
  16.         proveriHrana = new Semaphore(1);
  17.         spremno = new Semaphore(0);
  18.         trebadasezgotvi = new Semaphore(0);
  19.         sednijadi = new Semaphore(4);
  20.     }
  21.  
  22.     //  К А Н И Б А Л И
  23.     public static class TribeMember extends TemplateThread {
  24.  
  25.         public TribeMember(int numRuns) {
  26.             super(numRuns);
  27.         }
  28.         public static synchronized void stajSiHrana(){
  29.             state.fillPlate();
  30.         }
  31.         public static synchronized void proveriHrana() throws InterruptedException{
  32.             if(state.isPotEmpty()){
  33.                 trebadasezgotvi.release();
  34.                 spremno.acquire();
  35.             }
  36.         }
  37.  
  38.         @Override
  39.         public void execute() throws InterruptedException {
  40.             proveriHrana.acquire();
  41.             proveriHrana();
  42.             state.fillPlate();
  43.             proveriHrana.release();
  44.  
  45.             sednijadi.acquire();
  46.             state.eat();
  47.             sednijadi.release();
  48.         }
  49.  
  50.     }
  51.     // Г О Т В А Ч
  52.     public static class Chef extends TemplateThread {
  53.  
  54.         public Chef(int numRuns) {
  55.             super(numRuns);
  56.         }
  57.  
  58.         @Override
  59.         public void execute() throws InterruptedException {
  60.             trebadasezgotvi.acquire();
  61.             state.cook();
  62.             spremno.release();
  63.         }
  64.  
  65.     }
  66.  
  67.     static SeptemberTribeDinnerState state = new SeptemberTribeDinnerState();
  68.  
  69.     public static void main(String[] args) {
  70.         for (int i = 0; i < 3; i++) {
  71.             run();
  72.         }
  73.     }
  74.  
  75.     public static void run() {
  76.         try {
  77.             int numRuns = 1;
  78.             int numIterations = 150;
  79.  
  80.             HashSet<Thread> threads = new HashSet<Thread>();
  81.  
  82.             for (int i = 0; i < numIterations; i++) {
  83.                 TribeMember h = new TribeMember(numRuns);
  84.                 threads.add(h);
  85.             }
  86.  
  87.             Chef chef = new Chef(10);
  88.             threads.add(chef);
  89.  
  90.             init();
  91.  
  92.             ProblemExecution.start(threads, state);
  93.             //System.out.println(new Date().getTime());
  94.         } catch (Exception ex) {
  95.             ex.printStackTrace();
  96.         }
  97.     }
  98. }
  99.  
  100.  
  101.  
  102. class SeptemberTribeDinnerState extends AbstractState {
  103.  
  104.     private static final int EMPTY_POT = 0;
  105.  
  106.     private static final String _10_JADENJETO_NE_E_PARALELIZIRANO = "jadenjeto ne e paralelizirano. Site jadat eden po eden";
  107.  
  108.     private static final String _10_DVAJCA_ISTOVREMENO_PROVERUVAAT = "Dvajca istovremeno proveruvaat dali kazanot e prazen. Maksimum eden e dozvoleno.";
  109.     private static final String _7_DVAJCA_ISTOVREMENO_POLNAT = "Dvajca istovremeno zemaat hrana od kazanot. Maksimum eden e dozvoleno.";
  110.     private static final String _5_NE_MOZE_DA_POLNI_OD_PRAZEN_KAZAN = "Ne moze da se polni od kazan. Treba da se povika 'state.cook()'";
  111.     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";
  112.     private static final String _7_NEMA_MESTO_NA_TRPEZATA = "Trpezata e polna. Nema mesto na trpezata za poveke od cetvorica. ";
  113.     private static final String _7_NEMA_ZEMENO_HRANA = "NEMA ZEMENO HRANA";
  114.     private static final String _7_POLNI_OD_PRAZEN_KAZAN = "POLNI OD PRAZEN KAZAN";
  115.  
  116.     private static final int POT_CAPACITY = 15;
  117.  
  118.     private BoundCounterWithRaceConditionCheck platesLeft = new BoundCounterWithRaceConditionCheck(
  119.             0, null, 0, null, 0, 10, _7_POLNI_OD_PRAZEN_KAZAN);
  120.  
  121.     private BoundCounterWithRaceConditionCheck checks = new BoundCounterWithRaceConditionCheck(
  122.             0, 1, 10, _10_DVAJCA_ISTOVREMENO_PROVERUVAAT, null, 0, null);
  123.  
  124.     private BoundCounterWithRaceConditionCheck fills = new BoundCounterWithRaceConditionCheck(
  125.             0, 1, 7, _7_DVAJCA_ISTOVREMENO_POLNAT, 0, 5,
  126.             _5_NE_MOZE_DA_POLNI_OD_PRAZEN_KAZAN);
  127.  
  128.     private BoundCounterWithRaceConditionCheck ready = new BoundCounterWithRaceConditionCheck(
  129.             0, null, 0, null, 0, 7, _7_NEMA_ZEMENO_HRANA);
  130.  
  131.     private BoundCounterWithRaceConditionCheck eat = new BoundCounterWithRaceConditionCheck(
  132.             0, 4, 7, _7_NEMA_MESTO_NA_TRPEZATA, null, 0, null);
  133.  
  134.     public SeptemberTribeDinnerState() {
  135.  
  136.     }
  137.  
  138.     /**
  139.      * Maksimum 1 proveruva.
  140.      *
  141.      * @return
  142.      * @throws RuntimeException
  143.      */
  144.     public boolean isPotEmpty() throws RuntimeException {
  145.         log(checks.incrementWithMax(), "proverka dali ima hrana vo kazanot");
  146.         boolean res = platesLeft.getValue() == 0;
  147.         log(checks.decrementWithMin(), null);
  148.         return res;
  149.     }
  150.  
  151.     /**
  152.      * Maksimum 1 zema paralelno. Ne smee da se povika od prazen kazan.
  153.      *
  154.      * @throws RuntimeException
  155.      */
  156.     public void fillPlate() throws RuntimeException {
  157.         log(fills.incrementWithMax(), "zemanje na hrana");
  158.         log(platesLeft.decrementWithMin(false), null);
  159.         log(fills.decrementWithMin(), null);
  160.         ready.incrementWithMax(false);
  161.     }
  162.  
  163.     /**
  164.      * Maksimum 4 jadat paralelno. Ne smeat da jadat eden po eden.
  165.      *
  166.      * @throws RuntimeException
  167.      */
  168.     public void eat() throws RuntimeException {
  169.         log(ready.decrementWithMin(false), null);
  170.         log(eat.incrementWithMax(false), "jadenje");
  171.         Switcher.forceSwitch(15);
  172.         log(eat.decrementWithMin(false), null);
  173.  
  174.     }
  175.  
  176.     /**
  177.      * Se povikuva od gotvacot. Ne smee da se povika koga kazanot ne e prazen.
  178.      *
  179.      * @throws RuntimeException
  180.      */
  181.     public void cook() throws RuntimeException {
  182.         log(platesLeft.assertEquals(EMPTY_POT, 5,
  183.                 _5_NE_MOZE_DA_SE_GOTVI_VO_KAZAN_KOJ_NE_E_PRAZEN), null);
  184.         Switcher.forceSwitch(10);
  185.         platesLeft.setValue(POT_CAPACITY);
  186.     }
  187.  
  188.     @Override
  189.     public void finalize() {
  190.         if (eat.getMax() == 1) {
  191.             logException(new PointsException(10,
  192.                     _10_JADENJETO_NE_E_PARALELIZIRANO));
  193.         }
  194.     }
  195.  
  196. }
  197. abstract class AbstractState {
  198.  
  199.     /**
  200.      * Method called after threads ended their execution to validate the
  201.      * correctness of the scenario
  202.      */
  203.     public abstract void finalize();
  204.  
  205.     /**
  206.      * List of logged actions
  207.      */
  208.     private List<String> actions = new ArrayList<String>();
  209.  
  210.     /**
  211.      *
  212.      * @return if the current thread is instance of TemplateThread it is
  213.      *         returned, and otherwise null is returned
  214.      */
  215.     protected TemplateThread getThread() {
  216.         Thread current = Thread.currentThread();
  217.         if (current instanceof TemplateThread) {
  218.             TemplateThread t = (TemplateThread) current;
  219.             return t;
  220.         } else {
  221.             return null;
  222.         }
  223.     }
  224.  
  225.     /**
  226.      * Log this exception or action
  227.      *
  228.      * @param e
  229.      *            occurred exception (null if no exception)
  230.      * @param action
  231.      *            Description of the occurring action
  232.      */
  233.     public synchronized void log(PointsException e, String action) {
  234.         TemplateThread t = (TemplateThread) Thread.currentThread();
  235.         if (e != null) {
  236.             t.setException(e);
  237.             actions.add(t.toString() + "\t(e): " + e.getMessage());
  238.             throw e;
  239.         } else if (action != null) {
  240.             actions.add(t.toString() + "\t(a): " + action);
  241.         }
  242.     }
  243.  
  244.     /**
  245.      * Logging exceptions
  246.      *
  247.      * @param e
  248.      */
  249.     protected synchronized void logException(PointsException e) {
  250.         Thread t = Thread.currentThread();
  251.         if (e != null) {
  252.             if (t instanceof TemplateThread) {
  253.                 ((TemplateThread) t).setException(e);
  254.             }
  255.             TemplateThread.hasException = true;
  256.             actions.add("\t(e): " + e.getMessage());
  257.             throw e;
  258.         }
  259.     }
  260.  
  261.     /**
  262.      * Printing of the actions and exceptions that has occurred
  263.      */
  264.     public synchronized void printLog() {
  265.         System.out
  266.                 .println("Poradi konkurentnosta za pristap za pecatenje, mozno e nekoja od porakite da ne e na soodvetnoto mesto.");
  267.         System.out.println("Log na izvrsuvanje na akciite:");
  268.         System.out.println("=========================");
  269.         System.out.println("tip\tid\titer\takcija/error");
  270.         System.out.println("=========================");
  271.         for (String l : actions) {
  272.             System.out.println(l);
  273.         }
  274.     }
  275.  
  276.     /**
  277.      * Prints the status of the execution, with the exceptions that has occur
  278.      */
  279.     public void printStatus() {
  280.         try {
  281.             finalize();
  282.         } catch (Exception e) {
  283.             e.printStackTrace();
  284.         }
  285.         if (!TemplateThread.hasException) {
  286.             int poeni = 25;
  287.             if (PointsException.getTotalPoints() == 0) {
  288.                 System.out
  289.                         .println("Procesot e uspesno sinhroniziran. Osvoeni 25 poeni.");
  290.             } else {
  291.                 poeni -= PointsException.getTotalPoints();
  292.                 PointsException.printErrors();
  293.                 System.out.println("Maksimalni osvoeni poeni: " + poeni);
  294.             }
  295.  
  296.         } else {
  297.             System.out
  298.                     .println("Procesot ne e sinhroniziran spored uslovite na zadacata");
  299.             printLog();
  300.             System.out
  301.                     .println("====================================================");
  302.             PointsException.printErrors();
  303.             int total = (25 - PointsException.getTotalPoints());
  304.             if (total < 0) {
  305.                 total = 0;
  306.             }
  307.             System.out.println("Maksimum Poeni: " + total);
  308.         }
  309.  
  310.     }
  311. }
  312.  
  313. class PointsException extends RuntimeException {
  314.  
  315.     private static HashMap<String, PointsException> exceptions = new HashMap<String, PointsException>();
  316.     private int points;
  317.  
  318.     public PointsException(int points, String message) {
  319.         super(message);
  320.         this.points = points;
  321.         exceptions.put(message, this);
  322.     }
  323.  
  324.     public static int getTotalPoints() {
  325.         int sum = 0;
  326.         for (PointsException e : exceptions.values()) {
  327.             sum += e.getPoints();
  328.         }
  329.         return sum;
  330.     }
  331.  
  332.     public static void printErrors() {
  333.         if (!exceptions.isEmpty()) {
  334.             System.out.println("Gi imate slednite greski: ");
  335.             for (Map.Entry<String, PointsException> e : exceptions.entrySet()) {
  336.                 System.out.println(String.format("[%s] : (-%d)", e.getKey(), e
  337.                         .getValue().getPoints()));
  338.             }
  339.         }
  340.     }
  341.  
  342.     public int getPoints() {
  343.         return points;
  344.     }
  345. }
  346.  
  347. class Switcher {
  348.     private static final Random RANDOM = new Random();
  349.  
  350.     /*
  351.      * This method pauses the current thread i.e. changes its state to be
  352.      * Blocked. This should force thread switch if there are threads waiting
  353.      */
  354.     public static void forceSwitch(int range) {
  355.         try {
  356.             Thread.sleep(RANDOM.nextInt(range));
  357.         } catch (InterruptedException e) {
  358.         }
  359.     }
  360. }
  361.  
  362. abstract class TemplateThread extends Thread {
  363.  
  364.     static boolean hasException = false;
  365.     public int iteration = 0;
  366.     protected Exception exception = null;
  367.     int numRuns = 1;
  368.  
  369.     public TemplateThread(int numRuns) {
  370.         this.numRuns = numRuns;
  371.     }
  372.  
  373.     public abstract void execute() throws InterruptedException;
  374.  
  375.     @Override
  376.     public void run() {
  377.         try {
  378.             for (int i = 0; i < numRuns && !hasException; i++) {
  379.                 execute();
  380.                 iteration++;
  381.  
  382.             }
  383.         } catch (InterruptedException e) {
  384.             // Do nothing
  385.         } catch (Exception e) {
  386.             exception = e;
  387.             e.printStackTrace();
  388.             hasException = true;
  389.         }
  390.     }
  391.  
  392.     public void setException(Exception exception) {
  393.         this.exception = exception;
  394.         hasException = true;
  395.     }
  396.  
  397.     @Override
  398.     public String toString() {
  399.         Thread current = Thread.currentThread();
  400.         if (numRuns > 1) {
  401.             return String.format("[%d]%s\t%d\t%d", new Date().getTime(), ""
  402.                             + current.getClass().getSimpleName().charAt(0), getId(),
  403.                     iteration);
  404.         } else {
  405.             return String.format("[%d]%s\t%d\t", new Date().getTime(), ""
  406.                     + current.getClass().getSimpleName().charAt(0), getId());
  407.         }
  408.     }
  409. }
  410.  
  411. class BoundCounterWithRaceConditionCheck {
  412.  
  413.     private static final int RACE_CONDITION_POINTS = 25;
  414.     private static final String RACE_CONDITION_MESSAGE = "Race condition occured";
  415.  
  416.     private int value;
  417.     private Integer maxAllowed;
  418.     private Integer minAllowed;
  419.     private int maxErrorPoints;
  420.     private int minErrorPoints;
  421.     private String maxErrorMessage;
  422.     private String minErrorMessage;
  423.  
  424.     public static int raceConditionDefaultTime = 3;
  425.  
  426.     private int max;
  427.  
  428.     /**
  429.      *
  430.      * @param value
  431.      */
  432.     public BoundCounterWithRaceConditionCheck(int value) {
  433.         super();
  434.         this.value = value;
  435.         this.max = value;
  436.     }
  437.  
  438.     /**
  439.      *
  440.      * @param value
  441.      *            initial value
  442.      * @param maxAllowed
  443.      *            upper bound of the value
  444.      * @param maxErrorPoints
  445.      *            how many points are lost with the max value constraint
  446.      *            violation
  447.      * @param maxErrorMessage
  448.      *            message shown when the upper bound constrain is violated
  449.      * @param minAllowed
  450.      *            lower bound of the value
  451.      * @param minErrorPoints
  452.      *            how many points are lost with the min value constraint
  453.      *            violation
  454.      * @param minErrorMessage
  455.      *            message shown when the lower bound constrain is violated
  456.      */
  457.     public BoundCounterWithRaceConditionCheck(int value, Integer maxAllowed,
  458.                                               int maxErrorPoints, String maxErrorMessage, Integer minAllowed,
  459.                                               int minErrorPoints, String minErrorMessage) {
  460.         super();
  461.         this.value = value;
  462.         this.max = value;
  463.         this.maxAllowed = maxAllowed;
  464.         this.minAllowed = minAllowed;
  465.         this.maxErrorPoints = maxErrorPoints;
  466.         this.minErrorPoints = minErrorPoints;
  467.         this.maxErrorMessage = maxErrorMessage;
  468.         this.minErrorMessage = minErrorMessage;
  469.     }
  470.  
  471.     /**
  472.      *
  473.      * @return the maximum value of the integer variable that occurred at some
  474.      *         point of the execution
  475.      */
  476.     public int getMax() {
  477.         return max;
  478.     }
  479.  
  480.     /**
  481.      *
  482.      * @return the current value
  483.      */
  484.     public synchronized int getValue() {
  485.         return value;
  486.     }
  487.  
  488.     public synchronized void setValue(int value) {
  489.         this.value = value;
  490.     }
  491.  
  492.     /**
  493.      * Throws exception when the val is different than the value of the counter.
  494.      *
  495.      * @param val
  496.      * @param points
  497.      * @param errorMessage
  498.      * @return
  499.      */
  500.     public synchronized PointsException assertEquals(int val, int points,
  501.                                                      String errorMessage) {
  502.         if (this.value != val) {
  503.             PointsException e = new PointsException(points, errorMessage);
  504.             return e;
  505.         } else {
  506.             return null;
  507.         }
  508.     }
  509.  
  510.     public synchronized PointsException assertNotEquals(int val, int points,
  511.                                                         String errorMessage) {
  512.         if (this.value == val) {
  513.             PointsException e = new PointsException(points, errorMessage);
  514.             return e;
  515.         } else {
  516.             return null;
  517.         }
  518.     }
  519.  
  520.     /**
  521.      * Testing for race condition. NOTE: there are no guarantees that the race
  522.      * condition will be detected
  523.      *
  524.      * @return
  525.      */
  526.     public PointsException checkRaceCondition() {
  527.         return checkRaceCondition(raceConditionDefaultTime,
  528.                 RACE_CONDITION_MESSAGE);
  529.     }
  530.  
  531.     /**
  532.      * Testing for race condition. NOTE: there are no guarantees that the race
  533.      * condition will be detected, but higher the time argument is, the
  534.      * probability for race condition occurrence is higher
  535.      *
  536.      * @return
  537.      */
  538.     public PointsException checkRaceCondition(int time, String message) {
  539.         int val;
  540.  
  541.         synchronized (this) {
  542.             val = value;
  543.         }
  544.         Switcher.forceSwitch(time);
  545.         if (val != value) {
  546.             PointsException e = new PointsException(RACE_CONDITION_POINTS,
  547.                     message);
  548.             return e;
  549.         }
  550.         return null;
  551.  
  552.     }
  553.  
  554.     public PointsException incrementWithMax() {
  555.         return incrementWithMax(true);
  556.     }
  557.  
  558.     public PointsException incrementWithMax(boolean checkRaceCondition) {
  559.         if (checkRaceCondition) {
  560.             PointsException raceCondition = checkRaceCondition();
  561.             if (raceCondition != null) {
  562.                 return raceCondition;
  563.             }
  564.         }
  565.         synchronized (this) {
  566.             value++;
  567.  
  568.             if (value > max) {
  569.                 max = value;
  570.             }
  571.             if (maxAllowed != null) {
  572.                 if (value > maxAllowed) {
  573.                     PointsException e = new PointsException(maxErrorPoints,
  574.                             maxErrorMessage);
  575.                     return e;
  576.                 }
  577.             }
  578.         }
  579.  
  580.         return null;
  581.     }
  582.  
  583.     public PointsException decrementWithMin() {
  584.         return decrementWithMin(true);
  585.     }
  586.  
  587.     public PointsException decrementWithMin(boolean checkRaceCondition) {
  588.         if (checkRaceCondition) {
  589.             PointsException raceCondition = checkRaceCondition();
  590.             if (raceCondition != null) {
  591.                 return raceCondition;
  592.             }
  593.         }
  594.  
  595.         synchronized (this) {
  596.             value--;
  597.             if (minAllowed != null) {
  598.                 if (value < minAllowed) {
  599.                     PointsException e = new PointsException(minErrorPoints,
  600.                             minErrorMessage);
  601.                     return e;
  602.                 }
  603.             }
  604.         }
  605.         return null;
  606.     }
  607.  
  608. }
  609.  
  610. abstract class ProblemExecution {
  611.  
  612.     public static void start(HashSet<Thread> threads, AbstractState state)
  613.             throws Exception {
  614.  
  615.         startWithoutDeadlock(threads, state);
  616.  
  617.         checkDeadlock(threads, state);
  618.     }
  619.  
  620.     public static void startWithoutDeadlock(HashSet<Thread> threads,
  621.                                             AbstractState state) throws Exception {
  622.  
  623.         // start the threads
  624.         for (Thread t : threads) {
  625.             t.start();
  626.         }
  627.  
  628.         // wait threads to finish
  629.         for (Thread t : threads) {
  630.             t.join(1000);
  631.         }
  632.  
  633.     }
  634.  
  635.     private static void checkDeadlock(HashSet<Thread> threads,
  636.                                       AbstractState state) {
  637.         // check for deadlock
  638.         for (Thread t : threads) {
  639.             if (t.isAlive()) {
  640.                 t.interrupt();
  641.                 if (t instanceof TemplateThread) {
  642.                     TemplateThread tt = (TemplateThread) t;
  643.                     tt.setException(new PointsException(25, "DEADLOCK"));
  644.                 }
  645.             }
  646.         }
  647.  
  648.         // print the status
  649.         state.printStatus();
  650.     }
  651.  
  652. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top