package threads.blocking;


/**
 * I demonstrate creating blocking threads - useful for performing tasks with a timeout
 */
public class BlockingThreadTest {

	
	public static void main( String[] args ) {
		new BlockingThreadTest();
	}
	
	
	public BlockingThreadTest() {
		// create the blocking thread
		BlockingNumberGenerator b = new BlockingNumberGenerator( this, 5 );

		// synchronize on this - wait() must own the lock on the object to wait - wait() releases this lock
		synchronized ( this ) {
			// start the blocking thread
			new Thread( b ).start();
			try {
				// set the timeout
				this.wait(10 * 1000);
			} catch ( InterruptedException e ) {}
			
			if ( ! b.success() ) {
				// tell the blocking thread to stop
				b.stop();
				System.out.println( "TIMED OUT WHILE TRYING TO GENERATE THE NUMBER" );	
			} else {
				System.out.println( "SUCCESSFULLY GENERATED " + b.getNumber() );
			}
		}
	}
	
}



/**
 * I am a REALLY pointless class.  I take a reference to a calling class and take a number 
 * from 0 to 10, and try to randomly generate that number every second, indefinitely.
 */
class BlockingNumberGenerator implements Runnable {

	private final Object caller;
	private final int number;
	private boolean completed;
	private boolean run;

	
	public BlockingNumberGenerator( Object _caller, int _number ) {
		if ( _number > 10 || _number < 0 ) {
			throw new IllegalArgumentException( "Number must be between 0 and 10" );
		}
		caller = _caller;
		number = _number;
	}
	
	
	public void run() {
		// stop this thread to allow the calling process to complete its setup - may be redundant
		Thread.yield();
		
		run = true;
		// generate random numbers from 0 to 10 until the target number comes up
		System.out.println( "GENERATING RANDOM NUMBERS UNTIL I GET A " + number );
		int r = -1;
		while ( run && ( r = (int) ( Math.random() * 10 ) ) != number ) {
			try {
				Thread.sleep( 1000 );
			} catch ( InterruptedException e ) {
				// interrupt() may be called by the calling thread, to indicate that a timeout has occured
			}
		}
		
		if ( r == number ) {
			System.out.println( "GOT A " + number + "!!" );
			// set the completed flag
			completed = true;
		}

		// tell the calling thread that we're done - notify() must own the lock on the notifed object
		if ( ! Thread.interrupted() ) {
			// we only need to notify the caller if they didn't interrupt us - in this case that is impossible
			synchronized ( caller ) {
				caller.notify();			
			}
		}
	}
	
	
	/**
	 * I stop the generation of random numbers
	 */
	public void stop() {
		System.out.println( "STOPPED" );
		run = false;
	}
	
	
	/**
	 * @return if I was able to randomly generate the desired number
	 */
	public boolean success() {
		return completed;
	}
	
	
	/**
	 * @return the number I was able to randomly generate, or -1
	 */
	public int getNumber() {
		return success() ? number : -1;
	}
	
}