Advertisement
brsjak

OS - Tennis Tournament

Jan 21st, 2020
605
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 3.95 KB | None | 0 0
  1. import java.util.HashSet;
  2. import java.util.concurrent.Semaphore;
  3.  
  4. public class TennisTournament {
  5.    
  6.     static int red = 0;
  7.     static int green = 0;
  8.     static Semaphore lock = new Semaphore(1);
  9.     static Semaphore redEnter = new Semaphore(2);
  10.     static Semaphore greenEnter = new Semaphore(2);
  11.     static Semaphore canPlay = new Semaphore(0);
  12.     static boolean flag=false;
  13.    
  14.  
  15.     public static class GreenPlayer  extends Thread{
  16.    
  17.    
  18.         public void execute() throws InterruptedException {
  19.             System.out.println("Green player ready");
  20.             greenEnter.acquire();
  21.             lock.acquire();
  22.             green++;
  23.             if(red+green==4) {
  24.                 if(canPlay.availablePermits()==0) {
  25.                     canPlay.release(4);
  26.                    
  27.                 }
  28.             }
  29.             lock.release();
  30.             System.out.println("Green player enters field");
  31.             canPlay.acquire();
  32.             System.out.println("Match started");
  33.             Thread.sleep(200);
  34.             lock.acquire();
  35.             --green;
  36.             if(green == 0 && red == 0 ) {
  37.                 System.out.println("Match finished");
  38.                 if(redEnter.availablePermits()==0 && greenEnter.availablePermits()==0) {
  39.                     redEnter.release(2);
  40.                     greenEnter.release(2);
  41.                    
  42.                 }
  43.             } else {
  44.                 System.out.println("Green player finished playing");
  45.             }
  46.             lock.release();
  47.             // TODO: only one player calls the next line per match
  48.            
  49.            
  50.         }
  51.        
  52.         public void run() {
  53.             try {
  54.                 execute();
  55.                
  56.             }catch(InterruptedException e) {
  57.                 e.printStackTrace();
  58.             }
  59.         }
  60.  
  61.     }
  62.  
  63.     public static class RedPlayer extends Thread{
  64.  
  65.  
  66.        
  67.         public void execute() throws InterruptedException {
  68.             System.out.println("Red player ready");
  69.             redEnter.acquire();
  70.             lock.acquire();
  71.             red++;
  72.             if(red+green==4) {
  73.                 if(canPlay.availablePermits()==0) {
  74.                     canPlay.release(4);
  75.                    
  76.                 }
  77.             }
  78.             lock.release();
  79.             System.out.println("Red player enters field");
  80.             canPlay.acquire();
  81.             System.out.println("Match started");
  82.             Thread.sleep(200);
  83.             lock.acquire();
  84.             --red;
  85.             if(green == 0 && red == 0 ) {
  86.                 System.out.println("Match finished");
  87.                 if(redEnter.availablePermits()==0 && greenEnter.availablePermits()==0) {
  88.                     redEnter.release(2);
  89.                     greenEnter.release(2);
  90.                    
  91.                 }
  92.                
  93.             }else {
  94.                 System.out.println("Red player finished playing");
  95.             }
  96.             lock.release();
  97.         }
  98.        
  99.         public void run() {
  100.             try {
  101.                 execute();
  102.                
  103.             }catch(InterruptedException e) {
  104.                 e.printStackTrace();
  105.             }
  106.         }
  107.  
  108.     }
  109.  
  110.  
  111.     public static void main(String[] args) throws InterruptedException {
  112.         HashSet<Thread> threads = new HashSet<Thread>();
  113.         for (int i = 0; i < 30; i++) {
  114.             RedPlayer red = new RedPlayer();
  115.             threads.add(red);
  116.             GreenPlayer green = new GreenPlayer();
  117.             threads.add(green);
  118.         }
  119.         // start 30 red and 30 green players in background
  120.         for(Thread t : threads) {
  121.             t.start();
  122.         }
  123.         // after all of them are started, wait each of them to finish for 1_000 ms
  124.         for(Thread t : threads) {
  125.             t.join(1000);
  126.         }
  127.         for(Thread t : threads) {
  128.             if(t.isAlive()) {
  129.                 t.interrupt();
  130.                 System.err.println("Possible deadlock");
  131.             }
  132.         }
  133.         // after the waiting for each of the players is done, check the one that are not finished and terminate them
  134.        
  135.     }
  136.  
  137. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement