Object Oriented Design Pattern: Mediator

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import mediator.Customer;
import mediator.Mediator;
import mediator.Taxi;

public class Main {
	
	private static Collection<Taxi> taxiList = Collections.synchronizedList(new ArrayList<Taxi>());	
  
    public static void main(String[] args) {
    	    	
    	taxiList.add(new Taxi(0));
    	taxiList.add(new Taxi(25));
    	taxiList.add(new Taxi(50));
    	taxiList.add(new Taxi(75));
    	
    	Customer.startCustomerCreator();    
    	Mediator.startMediation(taxiList);
    }
    
}

package mediator;

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

public class Taxi {
	
	private static int nextId = 1;
	private int id;
	private Customer customer;
	private AtomicBoolean job = new AtomicBoolean(false);	
	private AtomicInteger location = new AtomicInteger();
	
	public Taxi(int location) {
		this.id = nextId++;
		this.location.set(location);
	}
	
	public int getId() {
		return this.id;
	}
		
	private synchronized void completeJob() {
		job.set(false);
		this.customer = null;
	}
	
	public synchronized boolean hasJob() {
		return job.get();
	}
	
	public int getLocation() {
		return this.location.get();
	}
	
	public boolean setJob(Customer customer) {
		if (this.customer == null && !hasJob()) {
			this.customer = customer;	
			return true;
		}
		else {
			throw new IllegalStateException(String.format("Taxi %1$d already has a job", this.id));
		}
	}
	
	/**
	 * Transport a customer
	 */
	public void runJob(Customer customer) {
		
		Thread taxiThread = new Thread(() -> {
			
			System.out.println(String.format("Taxi %1$d at %2$d is driving to customer: %3$s at %4$d ", this.id, this.location.get(), customer.getName(), customer.getFromLocation()));		
			
			int i = location.get(); // location of this taxi
			
			while (i != customer.getFromLocation()) {				
				if (i > customer.getFromLocation()) i--;
				else i++;		
				sleepThread(500);
			}			
			
			location = new AtomicInteger(i);
			System.out.println(String.format("Taxi %1$d arrived at customer %2$s at %3$d, going to %4$d", this.id, customer.getName(), this.location.get(), customer.getToLocation()));
			
			while (i != customer.getToLocation()) {				
				if (i > customer.getToLocation()) i--;
				else i++;		
				sleepThread(500);
			}		
			
			location = new AtomicInteger(i);
			
			System.out.println(String.format("Taxi %1$d delivered customer %2$s from %3$d to %4$d", this.id, customer.getName(), customer.getFromLocation(), customer.getToLocation()));
			
			completeJob();
		});
		
		if (!hasJob()) {
			this.job.set(true);
			taxiThread.start();
		}
		else {
			System.out.println(String.format("Taxi %1$d is currently busy", this.id));
		}		
	}
	
	public static void sleepThread(long millis) {
		try {
			Thread.sleep(millis);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
					
	}
	
}

package mediator;

import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicBoolean;

public class Customer {
	
	private String name;
	private int fromLocation, toLocation;
	private static AtomicBoolean customerCreatorActive = new AtomicBoolean(false);
	private static ConcurrentLinkedQueue<Customer> customerQueue = new ConcurrentLinkedQueue<Customer>();
	
	public int getFromLocation() {
		return this.fromLocation;
	}
	
	public int getToLocation() {
		return this.toLocation;
	}
	
	public String getName() {
		return this.name;
	}
	
	private static Customer createCustomer() {	
		Customer customer = new Customer();
		customer.name = generateRandomString(5);
		customer.fromLocation = ((int) (Math.round(Math.random() * 100)));
		customer.toLocation = ((int) (Math.round(Math.random() * 100)));
		return customer;
	}
	
	/**
	 * Creates new customers endlessly
	 */
	public static void startCustomerCreator() {
		
		Thread creationThread = new Thread(() -> {
			while (true) {
				final Customer customer = createCustomer();
				customerQueue.add(customer);
				System.out.println(String.format("New customer %1$s wants from %2$d to %3$d",customer.name, customer.fromLocation, customer.toLocation));
				try {
					long pace = (long) (Math.random() * 5000) + 10000;
					Thread.sleep(pace);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}				
			}			
		});
		
		if (customerCreatorActive.compareAndSet(false, true)) {
			creationThread.start();
		}
	}
	
	public static Customer getNextCustomer() {
		return customerQueue.poll();
	}    

    public static String generateRandomString(int length) {
    	String CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    	Random RANDOM = new Random();
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            int randomIndex = RANDOM.nextInt(CHARACTERS.length());
            sb.append(CHARACTERS.charAt(randomIndex));
        }
        return sb.toString();
    }
}

package mediator;

import java.util.Collection;
import java.util.concurrent.atomic.AtomicReference;

public class Mediator {
	
	private static final AtomicReference<Customer> customer = new AtomicReference<Customer>(); 
	
	/**
	 * Find nearest taxi for current customer
	 * @param taxiList
	 */
	public static void findNearestTaxi(Collection<Taxi> taxiList) {	
		
		Taxi nearestTaxi = null;
		int minDiff = Integer.MAX_VALUE;

		for (Taxi taxi : taxiList) {
		    if (!taxi.hasJob()) {
		        int diff = Math.abs(customer.get().getFromLocation() - taxi.getLocation());
		        if (diff < minDiff) {
		            minDiff = diff;
		            nearestTaxi = taxi;
		        }
		    }
		}
		
		if (nearestTaxi != null) {
			System.out.println(String.format("Best Taxi (%1$d) mediated at location %2$d ", nearestTaxi.getId(), nearestTaxi.getLocation()));
			if (nearestTaxi.setJob(customer.get())) {
				nearestTaxi.runJob(customer.get());
				customer.set(null);
			}
		}		
		else {
			System.out.println("All taxis occupied.");
		}
	}

	/**
	 * The mediation thread, which will match Customers with Taxi's
	 * @param taxiList
	 */
	public static void startMediation(Collection<Taxi> taxiList) {
		
		Thread mediationThread = new Thread( () -> {
			
			while(true) {
				
				// if we do not have a current customer to transfer, get the next in the queue
				if (customer.get() == null) {					
					customer.set(Customer.getNextCustomer());										
				}			
				else {
					System.out.print(String.format("Mediating for customer %1$s. -> ", customer.get().getName()));
					synchronized(taxiList) {
						findNearestTaxi(taxiList);
					}		
				}

				try {
					Thread.sleep(2500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		
		mediationThread.start();
	}
}