🚀 go-pugleaf

The reason suspend() and resume() are deprecated is because when you invoke
them, the executing thread does not release the lock.
Therefore it is dead-lock prone and risky.

I don't think that otherwise you can "suspend" and "resume" a thread exactly
from where you "stopped" it.
The following example illustrates a thread doing its work in a while loop.
Inside the loop, the executing thread has a boolean flag indicating whether
to snooze.
I hope this example will help.




import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


public class ThreadTest {

  public static void main(String[] args) {
    JFrame frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Container cp = frame.getContentPane();

    JButton stop  = new JButton("stop");
    JButton start = new JButton("Start");
    JButton exit  = new JButton("Exit");

    final DoSomething t = new DoSomething();
    t.start();

    // anonymous inner class
    stop.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        t.snooze();
      }
    });

    // anonymous inner class
    start.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        t.wakeUp();
      }
    });

    // anonymous inner class
    exit.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        t.stopRequest();
      }
    });



    cp.setLayout(new FlowLayout());
    cp.add(stop);
    cp.add(start);
    cp.add(exit);

    frame.setSize(300, 300);
    frame.setVisible(true);
  }

}


class DoSomething extends Thread {

  private volatile boolean noStopRequested = true;
  private volatile boolean isSnoozeTime    = false;
  private static int counter;

  public void run() {
    while(noStopRequested)
    {
      System.out.println("counter = " + counter);
      counter++;

      if(isSnoozeTime)
      {
        synchronized(this)
        {
          System.out.println("About to snooze");
          try { wait(); }
          catch(InterruptedException x) { x.printStackTrace(); }
          System.out.println("was notified - returned from wait()");
        }
      }
    }
  }


  public void stopRequest() {
    isSnoozeTime    = false;
    noStopRequested = false;

    // give a chance to the thread to die peacefuly.
    try { Thread.currentThread().sleep(200); }
    catch(InterruptedException x) { x.printStackTrace(); }
    this.interrupt();
  }


  public synchronized void wakeUp() {
    isSnoozeTime = false;
    this.notify();
  }


  public synchronized void snooze() { isSnoozeTime = true; }

}