Source Code : Boolean lock

Java Is Open Source Programming Language You Can Download From Java and Java Libraries From http://www.oracle.com. Click Here to download
We provide this code related to title for you to solve your developing problem easily. Libraries which is import in this program you can download from http://www.oracle.com. Click Here or search from google with Libraries Name you get jar file related it

Boolean lock

     

public class BestReplacement extends Object {
  private Thread internalThread;

  private volatile boolean stopRequested;

  private BooleanLock suspendRequested;

  private BooleanLock internalThreadSuspended;

  public BestReplacement() {
    stopRequested = false;

    suspendRequested = new BooleanLock(false);
    internalThreadSuspended = new BooleanLock(false);

    Runnable r = new Runnable() {
      public void run() {
        try {
          runWork();
        } catch (Exception x) {
          x.printStackTrace();
        }
      }
    };

    internalThread = new Thread(r);
    internalThread.start();
  }

  private void runWork() {
    int count = 0;

    while (!stopRequested) {
      try {
        waitWhileSuspended();
      } catch (InterruptedException x) {
        Thread.currentThread().interrupt();
        continue;
      }

      System.out.println("Part I - count=" + count);
      try {
        Thread.sleep(1000);
      } catch (InterruptedException x) {
        Thread.currentThread().interrupt();
      }

      System.out.println("Part II - count=" + count);

      try {
        Thread.sleep(1000);
      } catch (InterruptedException x) {
        Thread.currentThread().interrupt();
      }

      System.out.println("Part III - count=" + count);

      count++;
    }
  }

  private void waitWhileSuspended() throws InterruptedException {
    synchronized (suspendRequested) {
      if (suspendRequested.isTrue()) {
        try {
          internalThreadSuspended.setValue(true);
          suspendRequested.waitUntilFalse(0);
        } finally {
          internalThreadSuspended.setValue(false);
        }
      }
    }
  }

  public void suspendRequest() {
    suspendRequested.setValue(true);
  }

  public void resumeRequest() {
    suspendRequested.setValue(false);
  }

  public boolean waitForActualSuspension(long msTimeout)
      throws InterruptedException {
    return internalThreadSuspended.waitUntilTrue(msTimeout);
  }

  public void stopRequest() {
    stopRequested = true;
    internalThread.interrupt();
  }

  public boolean isAlive() {
    return internalThread.isAlive();
  }

  public static void main(String[] args) {
    try {
      BestReplacement br = new BestReplacement();
      System.out
          .println(" just created, br.isAlive()=" + br.isAlive());
      Thread.sleep(4200);

      long startTime = System.currentTimeMillis();
      br.suspendRequest();
      System.out.println(" just submitted a suspendRequest");

      boolean suspensionTookEffect = br.waitForActualSuspension(10000);
      long stopTime = System.currentTimeMillis();

      if (suspensionTookEffect) {
        System.out.println(" the internal thread took "
            + (stopTime - startTime) + " ms to notice "
            + "
    the suspend request and is now "
            + "suspended.");
      } else {
        System.out.println(" the internal thread did not notice "
            + "the suspend request " + "
    within 10 seconds.");
      }

      Thread.sleep(5000);

      br.resumeRequest();
      System.out.println("Submitted a resumeRequest");
      Thread.sleep(2200);

      br.stopRequest();
      System.out.println("Submitted a stopRequest");
    } catch (InterruptedException x) {
      // ignore
    }
  }
}
class BooleanLock extends Object {
  private boolean value;

  public BooleanLock(boolean initialValue) {
    value = initialValue;
  }

  public BooleanLock() {
    this(false);
  }

  public synchronized void setValue(boolean newValue) {
    if ( newValue != value ) {
      value = newValue;
      notifyAll();
    }
  }

  public synchronized boolean waitToSetTrue(long msTimeout) 
      throws InterruptedException {

    boolean success = waitUntilFalse(msTimeout);
    if ( success ) {
      setValue(true);
    }

    return success;
  }

  public synchronized boolean waitToSetFalse(long msTimeout) 
      throws InterruptedException {

    boolean success = waitUntilTrue(msTimeout);
    if ( success ) {
      setValue(false);
    }

    return success;
  }

  public synchronized boolean isTrue() {
    return value;
  }

  public synchronized boolean isFalse() {
    return !value;
  }

  public synchronized boolean waitUntilTrue(long msTimeout) 
      throws InterruptedException {

    return waitUntilStateIs(true, msTimeout);
  }

  public synchronized boolean waitUntilFalse(long msTimeout) 
      throws InterruptedException {

    return waitUntilStateIs(false, msTimeout);
  }

  public synchronized boolean waitUntilStateIs(
        boolean state, 
        long msTimeout
      ) throws InterruptedException {

    if ( msTimeout == 0L ) {
      while ( value != state ) {
        wait();
      }

      return true;
    } 

    long endTime = System.currentTimeMillis() + msTimeout;
    long msRemaining = msTimeout;

    while ( ( value != state ) && ( msRemaining > 0L ) ) {
      wait(msRemaining);
      msRemaining = endTime - System.currentTimeMillis();
    }

    return ( value == state );
  }
}

           
         
    
    
    
    
  

Thank with us