Here is a design to achieve a simple model in Java which uses a Thread and has these features:Starting the thread with an initial valuePausing the threadResuming the thread with new valueStopping the threadRestrictions: Do not use already implemented java libraries (from the concurrent package).A similar question was asked on SO where I have answered with this code, but I want to get some review comments for the same.I defined an interface for the model:/** *  * @author krishna.k *  * This defines the methods for the model. * */public interface IResumable {  /**   * starts the model   */  public void requestStart();  /**   * requests the model to pause   */  public void requestPause();  /**   * requests the model to resume with new parameter   * @param newParam   */  public void resumeWithNewParam(int newParam);  /**   * terminate the model   */  public void requestStop();}The concrete Model:public class ResumableModel implements IResumable {  private Thread worker;  private WorkerRunnable work;  public ResumableModel(int initialValue) {        work = new WorkerRunnable(initialValue);        worker = new Thread(work);  }  @Override  public void requestStart() {        worker.start();  }  @Override  public void requestPause() {        work.setPauseRequested(true);  }  @Override  public void resumeWithNewParam(int newParam) {        work.setNewParam(newParam);  }  @Override  public void requestStop() {        worker.interrupt();  }  private static class WorkerRunnable implements Runnable {        private int param; // we can have the variable of the type depending                                      // upon        // the requirement.        private final Object lock = new Object();        private volatile boolean isPauseRequested = false;        public void run() {              synchronized (lock) {                    try {                          while (!Thread.currentThread().isInterrupted()) {                                while (isPauseRequested) {                                      lock.wait();                                }                                System.out.println(value of param is + param);                          }                    } catch (InterruptedException e) {                          e.printStackTrace();                    }              }        }        public WorkerRunnable(int param) {              this.param = param;        }        private void setPauseRequested(boolean isPauseRequested) {              this.isPauseRequested = isPauseRequested;        }        private void setNewParam(int param) {              // double locking to prevent the calling thread from being locked              // (if in running state without pause requested then calling thread              // will be in indefinite wait state for acquiring the lock.              if (isPauseRequested) {                    synchronized (lock) {                          if (isPauseRequested) {                                this.param = param;                                this.isPauseRequested = false;                                lock.notifyAll();                          } else {                                // logger will be used in real application                                System.out.println(Need to pause first before setting a new param);                           }                    }              } else {                    // logger will be used in real application                    System.out.println(Need to pause first before setting a new param);               }        }  }}The testing driver code:public class Test {  public static void main(String[] args) throws InterruptedException {        IResumable resumable = new ResumableModel(10);        resumable.requestStart();        //Current thread is Main thread        Thread.currentThread().sleep(3000); // making the main thread sleep for 3 seconds.        resumable.requestPause();        Thread.currentThread().sleep(3000); // again making the main thread sleep for 3 seconds.        resumable.resumeWithNewParam(20);        Thread.currentThread().sleep(3000); // again making the main thread sleep for 3 seconds.        resumable.requestStop();  }}Please provide review comments and feedback. It will help me and the people to whom I tell this approach.
Model for starting a thread with an initial value, pausing, resuming with a new value and stopping a thread
java;multithreading