CREATE DATABASE emp;

USE emp;

CREATE TABLE dept_data
(
   DEPTNO int,
   DNAME varchar(50),
   LOC varchar(50),
   PRIMARY KEY (DEPTNO)
);


INSERT INTO dept_data ( DEPTNO, DNAME, LOC )
VALUES (10, 'ACCOUNTING', 'NEW YORK'), (20 ,'RESEARCH', 'DALLAS'),
(30, 'SALES', 'CHICAGO'), (40, 'OPERATIONS', 'BOSTON');


CREATE TABLE emp_data
(
  EMPNO int,
  ENAME varchar(50),
  JOB varchar(50),
  MGR int,
  HIREDATE ??
)

struct Semaphore {
  int count;
  queueType queue;

  init(int init_value){
    count = init_value;
    queue = empty;
  }

  wait(){
    count = count - 1;
    if(count < 0){
      //put this process in the semaphore's queue
      //block this process on OS level
    }
  }

  signal(){
    count = count + 1;
    if(count <= 0){
      //remove some process P from semaphore's queue
      //move process P to ready queue on OS level
    }
  }
}

Semaphore sem := sem.init(2);
boolean[] occupiedShower := { false, false }
runInParallel { S1 } ... { Sn }

Swimmer {
  run {
    sem.wait();
    if(occupiedShower[0])
      shower(1);
    else
      shower(0);
    sem.signal();
  }

  shower(int numOfShower){
    if(numOfShower == 1){
      occupiedShower[1] = true;
      //...thoroughly clean all body parts in the shower
      occupiedShower[1] = false;
    }
    else{
      occupiedShower[0] = true;
      //...thoroughly clean all body parts in another shower
      occupiedShower[0] = false;
  }
}

Initialization of shared variables and semaphores:
	Semaphore sem_condition.init(2);
	Semaphore sem_me.init(1);
	boolean[] occupiedShower = { false, false }
	//
	//sem_condition is responsible for condition synchronization, and only allows two swimmers 
	//  to enter the shower area at the same time. If more than two swimmers try to enter the showers at                
	//  the same time, only the first two can enter, others have to wait in line.
	//sem_me is responsible for mutual exclusion, to make sure that two swimmers in the shower area won't try 
        //  to occupy the same shower simultaneously.
	//occupiedShower knows whether the showers are occupied or not.
	
Swimmer code:
Swimmer {
	enterShowerArea {
		//Swimmer tries to enter shower area, waits if it's full.
		sem_condition.wait(); 
		
		//Swimmer tries to pick a shower, waits if another swimmer is picking a shower.
		sem_me.wait();  
		
		//Swimmer checks if first shower (shower 0) is occupied.
		if(occupiedShower[0]){  
			//If it is occupied, then swimmer occupies second shower (shower 1).
			occupyShower(1);
		}
		else {
			//If first shower isn't occupied, then swimmer occupies it.
			occupyShower(0);
		}
		
		//Swimmer signals that he has picked a shower,if another swimmer was waiting then now he can pick.
		sem_me.signal();
		
		//Swimmer signals that he has left the shower area, if another swimmer was waiting now he can enter.
		sem_condition.signal();
	}
	
	occupyShower(int showerNumber){
		occupiedShower[showerNumber] = true;
		//…Wash whole body thoroughly with soap before big swimming competition….
		occupiedShower[showerNumber] = false;
	}
}