new synchronization problems

Author: ristes

synchronization/src/main/java/mk/ukim/finki/os/synchronization/exam14/march/ca3n2/CalciumNitride.java

@@ -52,22 +52,27 @@ public void execute() throws InterruptedException {
 caNum++;
 if (caNum == 3) {
 // tret ca atom
-caNum = 0;
 lock.release();
 nHere.acquire(2);
-ready.release(4);
-state.bond();
-bondingDone.acquire(4);
-canLeave.release(4);
-state.validate();
+ready.release(5);
+} else {
+// prv i vtor ca atom
+lock.release();
+}
+ready.acquire();// x2 ca atoms
+state.bond();
+bondingDone.release();
+lock.acquire();
+caNum--;
+if (caNum == 0) {
+// tret ca atom
+lock.release();
+bondingDone.acquire(5);
+n.release(2);
 ca.release(3);
 } else {
 // prv i vtor ca atom
 lock.release();
-ready.acquire();// x2 ca atoms
-state.bond();
-bondingDone.release();
-canLeave.acquire();
 }
 }
 
@@ -86,8 +91,7 @@ public void execute() throws InterruptedException {
 ready.acquire(); // x2 n atoms
 state.bond();
 bondingDone.release();
-canLeave.acquire();
-n.release();
+
 }
 
 }

synchronization/src/main/java/mk/ukim/finki/os/synchronization/exam18/backup/MainG2.java

@@ -0,0 +1,186 @@
+package mk.ukim.finki.os.synchronization.exam18.backup;
+
+import java.util.*;
+import java.util.concurrent.Semaphore;
+
+/**
+ * @author Riste Stojanov
+ */
+public class MainG2 {
+
+ /**
+ * Don't change this method
+ *
+ * @return
+ */
+ private static final List<DistanceVectorRouter> initNetwork() {
+ List<DistanceVectorRouter> routers = new ArrayList<>();
+
+ DistanceVectorRouter first = new DistanceVectorRouter("X1");
+ DistanceVectorRouter second = new DistanceVectorRouter("X2", first);
+ DistanceVectorRouter third = new DistanceVectorRouter("X3", first);
+ routers.add(first);
+ routers.add(second);
+ routers.add(third);
+ for (int i = 3; i < 10; i++) {
+ DistanceVectorRouter next = new DistanceVectorRouter("X" + i, first, second, third);
+ first = second;
+ second = third;
+ third = next;
+ routers.add(next);
+ }
+ for (DistanceVectorRouter router : routers) {
+ System.out.println(router + "\n\t" + router.neighbors + "\n\t" + router.routingTable);
+ }
+ return routers;
+ }
+
+ /**
+ * Finish the todo requirements
+ *
+ * @param args
+ * @throws InterruptedException
+ */
+ public static void main(String[] args) throws InterruptedException {
+
+ List<DistanceVectorRouter> routers = initNetwork();
+ List<Thread> threads = new ArrayList<>();
+
+ for (DistanceVectorRouter router : routers) {
+ // todo: run this in background
+ Thread t = new Thread(() -> router.keepAliveHartBeat());
+ threads.add(t);
+ t.start();
+
+ // todo: run this in other thread
+ Thread t1 = new Thread(() -> router.handleChangesInBackground());
+ threads.add(t1);
+ t1.start();
+ }
+
+ // todo: wait for 10_000 ms and terminate all routers
+ Thread.sleep(10_000);
+ for (Thread thread : threads) {
+ thread.interrupt();
+ }
+ System.out.println("DONE!");
+
+ }
+}
+
+class DistanceVectorRouter {
+
+ final Set<DistanceVectorRouter> neighbors = new HashSet<>();
+ final Map<String, Integer> routingTable = new HashMap<>();
+ private final Queue<Map<String, Integer>> advertisements = new LinkedList<>();
+ private final String network;
+ boolean routingTableChanged = false;
+ private Semaphore hasMessage = new Semaphore(0);
+
+ /**
+ * Don't change this method
+ *
+ * @param neighbors
+ */
+ public DistanceVectorRouter(String network, DistanceVectorRouter... neighbors) {
+ this.network = network;
+ this.routingTable.put(network, 1);
+ for (DistanceVectorRouter neighbor : neighbors) {
+ neighbor.neighbors.add(this);
+ this.neighbors.add(neighbor);
+ this.routingTable.put(neighbor.network, 1);
+ }
+ }
+
+ /**
+ * Don't change this method
+ *
+ * @param invoker
+ */
+ public void notifyNeighbors(String invoker) {
+ for (DistanceVectorRouter neighbor : neighbors) {
+ System.out.println(invoker + " " + network + " notifying " + neighbor.network);
+ neighbor.notifyAdvertisement(routingTable);
+ }
+ }
+
+ public void notifyAdvertisement(Map<String, Integer> routingTable) {
+ synchronized (advertisements) {
+ advertisements.add(routingTable);
+ hasMessage.release();
+ }
+ }
+
+ /**
+ * Don't change this method
+ */
+ public void keepAliveHartBeat() {
+ Thread.currentThread().setName("keep alive [" + network + "]: ");
+ try {
+ notifyNeighbors("keep alive");
+ Thread.sleep(5000);
+ notifyNeighbors("keep alive");
+ } catch (InterruptedException e) {
+ System.out.println(Thread.currentThread().getName() + " interrupted");
+ }
+ }
+
+ /**
+ * TODO: finish this method
+ */
+ public void handleChangesInBackground() {
+ try {
+ Thread.currentThread().setName("handle changes [" + network + "]: ");
+ while (true) {
+ routingTableChanged = false;
+ // todo: wait for message from the neighbors
+ hasMessage.acquire();
+ synchronized (advertisements) {
+ // todo: only one call at a given time is allowed for the nextAdvertisement() method
+ Map<String, Integer> advertisement = advertisements.poll();
+
+ calculateRoutingTable(advertisement);
+ }
+
+ if (routingTableChanged) {
+ System.out.println("new routing table: " + routingTable);
+ notifyNeighbors("\t\thandle changes");
+ }
+ }
+ } catch (InterruptedException e) {
+ System.out.println(Thread.currentThread().getName() + " interrupted");
+ }
+ }
+
+ /**
+ * Don't change this method
+ *
+ * @param advertisement
+ */
+ private final void calculateRoutingTable(Map<String, Integer> advertisement) {
+ System.out.println(Thread.currentThread().getName() + " calculating routing table");
+ synchronized (advertisement) {
+ advertisement.forEach((net, price) -> {
+ Integer oldPrice = routingTable.get(net);
+ if (oldPrice == null || (price + 1) < oldPrice) {
+ synchronized (routingTable) {
+ routingTable.put(net, price + 1);
+ }
+ routingTableChanged = true;
+ }
+ });
+ }
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof DistanceVectorRouter)
+ return network.equals(((DistanceVectorRouter) obj).network);
+ return false;
+ }
+
+ @Override
+ public String toString() {
+ return network;
+ }
+}

synchronization/src/main/java/mk/ukim/finki/os/synchronization/exam18/s3/EventProcessor.java

@@ -0,0 +1,61 @@
+package mk.ukim.finki.os.synchronization.exam18.s3;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class EventProcessor {
+
+ public static Random random = new Random();
+ static List<EventGenerator> scheduled = new ArrayList<>();
+
+ public static void main(String[] args) throws InterruptedException {
+ List<EventProcessor> processors = new ArrayList<>();
+ // TODO: kreirajte 20 Processor i startuvajte gi vo pozadina
+ for (int i = 0; i < 20; i++) {
+ EventProcessor p = new EventProcessor();
+ processors.add(p);
+ //TODO: startuvajte go vo pozadina
+ }
+
+ for (int i = 0; i < 100; i++) {
+ EventGenerator eventGenerator = new EventGenerator();
+ //TODO: startuvajte go eventGenerator-ot
+
+ }
+
+
+ for (int i = 0; i < 20; i++) {
+ EventProcessor p = processors.get(i);
+ // TODO: Cekajte 20000ms za Processor-ot p da zavrsi
+
+ // TODO: ispisete go statusot od izvrsuvanjeto
+ }
+ }
+
+
+ public static void process() {
+ // TODO: pocekajte 5 novi nastani
+
+ System.out.println("processing event");
+ }
+
+}
+
+
+class EventGenerator {
+
+ public Integer duration;
+
+ public EventGenerator() throws InterruptedException {
+ this.duration = EventProcessor.random.nextInt(1000);
+ }
+
+
+ /**
+ * Ne smee da bide povikan paralelno kaj poveke od 5 generatori
+ */
+ public static void generate() {
+ System.out.println("Generating event: ");
+ }
+}

synchronization/src/main/java/mk/ukim/finki/os/synchronization/exam18/s3/event-processing.md

@@ -0,0 +1,87 @@
+Event Processing Simulation
+============================
+
+Потребно е да извршите симулација за процесирање на настани со дефининираните 
+класи `EventGenerator` и `Processor` кои треба да функционираат како thread-ови. 
+
+Главниот метод `Processor.main` да стартува 20 `Processor` thread-ови и потоа треба да стартува 100 нови `EventGenerator` 
+thread-ови во позадина. Потоа `main` методот треба да ги чека `Processor` thread-овите да завршат за најмногу 20000ms. 
+Доколку не завршат за ова време, треба да се прекинат и да се испише порака `Terminated processing`, а во спротивен 
+случај да се испише `Finished processing`. 
+
+
+Секој од `EventGenerator` thread-овите веднаш по стартувањето во позадина да заспие рандом време со
+`Thread.sleep(this.duration)`, по што треба да го генерира настанот со методот `generate()` кој **не смее** да се извршува
+паралелно кај **повеќе од 5 генератори**. Потоа треба да се извести `Processor` thread-от дека има нов настан за процесирање. 
+Додека не заврши ова процесирање, не смеат да се генерираат нови настани. 
+
+Секоја од `Processor` класите е Thread, кој во позадина чека да биде известен за **5 нови настани**,
+по што ги процесира со користење на методот `process()`. Дури откако ќе заврши овој метод, може да се продолжи со 
+генерирање на нови настани, а во меѓувреме сите `EventGenerator`-и го чекаат овој метод да заврши.
+
+Вашата задача е да го дополните дадениот код според барањата на задачата, при што треба да внимавате 
+не настане Race Condition и Deadlock. 
+
+```
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class EventProcessor {
+
+ public static Random random = new Random();
+ static List<EventGenerator> scheduled = new ArrayList<>();
+
+ public static void main(String[] args) throws InterruptedException {
+ List<EventProcessor> processors = new ArrayList<>();
+ // TODO: kreirajte 20 Processor i startuvajte gi vo pozadina
+ for (int i = 0; i < 20; i++) {
+ EventProcessor p = new EventProcessor();
+ processors.add(p);
+ //TODO: startuvajte go vo pozadina
+ }
+
+ for (int i = 0; i < 100; i++) {
+ EventGenerator eventGenerator = new EventGenerator();
+ //TODO: startuvajte go eventGenerator-ot
+
+ }
+
+
+ for (int i = 0; i < 20; i++) {
+ EventProcessor p = processors.get(i);
+ // TODO: Cekajte 20000ms za Processor-ot p da zavrsi
+
+ // TODO: ispisete go statusot od izvrsuvanjeto
+ }
+ }
+
+
+ public static void process() {
+ // TODO: pocekajte 5 novi nastani
+
+ System.out.println("processing event");
+ }
+
+}
+
+
+class EventGenerator {
+
+ public Integer duration;
+
+ public EventGenerator() throws InterruptedException {
+ this.duration = EventProcessor.random.nextInt(1000);
+ }
+
+
+ /**
+ * Ne smee da bide povikan paralelno kaj poveke od 5 generatori
+ */
+ public static void generate() {
+ System.out.println("Generating event: ");
+ }
+}
+```
+