Ufdjrw

I am working on java version upgrade project and I am on the work where I need to replace deprecated methods.

this.stop();

Code USed this method are in ::

ThreadedTestGroup.java::

 package utmj.threaded;

import junit.framework.*;
public class ThreadedTestGroup extends ThreadGroup 
 private Test test;
 private TestResult testResult;

 public ThreadedTestGroup(Test test) 
 super("ThreadedTestGroup");
 this.test = test;
 


 public void interruptThenStop() 
 this.interrupt();
 if (this.activeCount() > 0) 
 this.stop(); // For those threads which won't interrupt
 
 


 public void setTestResult(TestResult result) 
 testResult = result;
 


 public void uncaughtException(Thread t, Throwable e) 
 if (e instanceof ThreadDeath) 
 return;
 
 if (e instanceof AssertionFailedError) 
 testResult.addFailure(test, (AssertionFailedError) e);
 else 
 testResult.addError(test, e);
 
 this.interruptThenStop();
 

CobcyrrentTestCase.java

 package utmj.threaded;

import java.util.*;

import junit.framework.*;

/
public class ConcurrentTestCase extends TestCase 
 private TestResult currentResult;
 private ThreadedTestGroup threadGroup;
 private Hashtable threads = new Hashtable();
 private boolean deadlockDetected = false;
 private Vector checkpoints = new Vector();

 class ConcurrentTestThread extends Thread 
 private volatile boolean hasStarted = false;
 private volatile boolean hasFinished = false;
 ConcurrentTestThread(
 ThreadGroup group,
 Runnable runnable,
 String name) 
 super(group, runnable, name);
 
 public void run() 
 hasStarted = true;
 super.run();
 finishThread(this);
 
 

 public ConcurrentTestCase(String name) 
 super(name);
 

 public ConcurrentTestCase() 
 super();
 

 protected void addThread(String name, final Runnable runnable) 
 if (threads.get(name) != null) 
 fail("Thread with name '" + name + "' already exists");
 
 ConcurrentTestThread newThread =
 new ConcurrentTestThread(threadGroup, runnable, name);
 threads.put(name, newThread);
 

 public synchronized void checkpoint(String checkpointName) 
 checkpoints.addElement(checkpointName);
 this.notifyAll();
 

 public boolean checkpointReached(String checkpointName) 
 return checkpoints.contains(checkpointName);
 

 public boolean deadlockDetected() 
 return deadlockDetected;
 

 private synchronized void finishThread(ConcurrentTestThread thread) 
 thread.hasFinished = true;
 this.notifyAll();
 

 private ConcurrentTestThread getThread(String threadName) 
 return (ConcurrentTestThread) threads.get(threadName);
 

 /**
 * Returns true if the thread finished normally, i.e. was not inerrupted or stopped
 */
 public boolean hasThreadFinished(String threadName) 
 ConcurrentTestThread thread = this.getThread(threadName);
 if (thread == null) 
 fail("Unknown Thread: " + threadName);
 
 return thread.hasFinished;
 

 public boolean hasThreadStarted(String threadName) 
 ConcurrentTestThread thread = this.getThread(threadName);
 if (thread == null) 
 fail("Unknown Thread: " + threadName);
 
 return thread.hasStarted;
 

 private void interruptAllAliveThreads() 
 threadGroup.interruptThenStop();
 

 /**
 * Wait till all threads have finished. Wait maximally millisecondsToWait.
 * Should only be called after startThreads().
 */
 protected void joinAllThreads(long millisecondsToWait) 
 Enumeration enum1 = threads.elements();
 long remainingMilliseconds = millisecondsToWait;
 while (enum1.hasMoreElements()) 
 long before = System.currentTimeMillis();
 ConcurrentTestThread each =
 (ConcurrentTestThread) enum1.nextElement();
 try 
 each.join(remainingMilliseconds);
 catch (InterruptedException ignored) 
 
 long spent = System.currentTimeMillis() - before;
 if (millisecondsToWait != 0) 
 remainingMilliseconds = remainingMilliseconds - spent;
 if (remainingMilliseconds <= 0) 
 deadlockDetected = true;
 break;
 
 
 
 

 public void joinThread(String threadName) throws InterruptedException 
 this.joinThread(threadName, 0);
 

 public void joinThread(String threadName, long millisecondsToTimeout)
 throws InterruptedException 
 ConcurrentTestThread thread = this.getThread(threadName);
 if (thread == null) 
 fail("Unknown Thread: " + threadName);
 
 thread.join(millisecondsToTimeout);
 

 /**
 * Stores the current result to be accessible during the test
 */
 public void run(TestResult result) 
 currentResult = result;
 super.run(result);
 

 protected void setUp() throws Exception 
 threadGroup = new ThreadedTestGroup(this);
 

 /**
 * Sleep and ignore interruption
 */
 public void sleep(long milliseconds) 
 try 
 Thread.sleep(milliseconds);
 catch (InterruptedException ignored) 
 
 

 /**
 * Run all threads and wait for them to finish without timeout
 */
 protected void startAndJoinAllThreads() 
 this.startAndJoinThreads(0);
 


 protected void startThreads() 
 threadGroup.setTestResult(currentResult);
 Enumeration enum1 = threads.elements();
 while (enum1.hasMoreElements()) 
 ConcurrentTestThread each =
 (ConcurrentTestThread) enum1.nextElement();
 each.start();
 each.hasStarted = true;
 
 Thread.yield();
 



 protected void tearDown() throws Exception 
 this.interruptAllAliveThreads();
 threads = new Hashtable();
 checkpoints = new Vector();
 deadlockDetected = false;
 threadGroup = null;
 currentResult = null;
 

 public synchronized void waitForCheckpoint(String checkpointName) 
 while (!this.checkpointReached(checkpointName)) 
 try 
 this.wait();
 catch (InterruptedException ignored) 
 
 
 


 public synchronized void waitUntilFinished(String threadName) 
 while (!this.hasThreadFinished(threadName)) 
 try 
 this.wait();
 catch (InterruptedException ignored) 
 
 
 

I tried to search lot about this but did not got suitable solution so is there anyone who can help me out to replace this.stop() method which is deprecated.

IDE message: The method stop() from the type ThreadGroup is deprecated

There is no single method that replaces stop() from Thread Group but rather a design approach

From the oracle documentation it says

Many uses of stop should be replaced by code that simply modifies
some variable to indicate that the target thread should stop running.
The target thread should check this variable regularly, and return
from its run method in an orderly fashion if the variable indicates
that it is to stop running

Looking at the samples on What should I use instead of Thread.stop?

private volatile Thread blinker;

public void stop() 
 blinker = null;


public void run() 
 Thread thisThread = Thread.currentThread();
 while (blinker == thisThread) 
 try 
 Thread.sleep(interval);
 catch (InterruptedException e)
 
 repaint();
 

Throughout your thread, you need to check on a thread safe variable (in the example above its blinker) ... when stop is called, it sets the thread to null breaking out of the while loop and returning from run... thereby "stopping" the thread

Well I red a bit of the documentation about why stop() is deprecated and here is the most relevant part :

This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply m>odifies some variable to indicate that the target thread should stop running. The target thread should check this variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method should be used to interrupt the wait.

With those details, I think there is no more a simple way to stop all the threads as stop() did. You might need to modifie the threads so that you have a way to stop them (if it is possible for you).