Platform Solaris:


Included is a test case that demonstrates the fact that  you can't  stop
a thread that is blocked on a socket read.



import java.net.*;

public class Timeout implements Runnable
{
	public static void main(String args[])
	{
		try
		{
			TestThread th = new TestThread();
			th.run();
			th.join();

			//	(We never get here -- this is the bug)
			System.out.println("TestThread has stopped!");
		}
		catch( Exception e ) { };
	}

	public void run()
	{
	}
}

class TestThread extends Thread
{
	public void run()
	{
		try
		{
			DatagramSocket s = new DatagramSocket();
			DatagramPacket packet = new DatagramPacket(new byte[100],100);

			//	Create a ThreadKiller object to kill this thread in 5 seconds.
			//	We are blocking on the DatagramSocket.receive() function, which
			//	we don't expect to ever receive a packet in this demonstration.
			//	When the ThreadKiller kicks in and calls stop on this thread,
			//	it has no effect.  It should stop the thread   This is the bug.
			//
			System.out.println("Waiting for packet (timeout in 5 seconds)...");

			ThreadKiller killer = new ThreadKiller(this,5000);
			killer.start();
			s.receive(packet);
			killer.Dismiss();

			System.out.println("Exiting TestThread.run()");
		}
		catch( Exception e ){ };
	}
}

/*
**	Thread class to kill other threads after a timeout occurs.
**	The thread sleeps for the specified amount of milliseconds;
**	when it wakes up it kills the target thread unless the
**	Dismiss function is called.
*/
class ThreadKiller extends Thread
{
	boolean 			fDismissed = false;
	long 				fDuration = 5000;
	Thread	 			fTarget = null;

	/***
	*	Constructor
	*	@param targetThread The thread to kill
	*	@param msDuration The amount of time that will elapse before the
	*		target thread is killed.
	*/
	ThreadKiller( Thread targetThread, long msDuration )
	{
		super("ThreadKiller");
		fDuration=msDuration;
		fTarget=targetThread;
	}

	/*
	**	Thread execution.
	*/
	public void run()
	{
		try
		{
			System.out.println("Waking up in "+fDuration+" ms");
			sleep(fDuration);
		}
		catch( InterruptedException e )
		{
			System.out.println("ThreadKiller.run: Exception: "+e);
		}

		if( !fDismissed && fTarget != null ) {
			System.out.println("Stopping thread: "+fTarget);
			fTarget.stop();
		}
	}

	/*
	**	Call to dismiss this thread; when it wakes up it will not kill the
	**	target thread.
	*/
	public void Dismiss()
	{
		System.out.println("Dismissed");
		fDismissed=true;
	}
}