import java.applet.Applet; public class MyJoinApplet extends Applet { Thread t[] = new Thread[30]; public void start() { for (int i=0; i<30; i++) { t[i] = new CalcThread(i); t[i].start(); } } public void stop() { for (int i=0; i<30; i++) { try { t[i].join(); } catch (InterruptedException e) {} } } }

public void stop() { t.stop(); while (t.isAlive()) { try { Thread.sleep(100); // not an error - see API } catch Interrupted Exception e) {} } }

The thread object, like any other object, is a candidate for garbage collection when it gets dereferenced. Garbage collection cannot collect the thread object even when the thread has been completed or stopped. This is because we still have a reference to the thread object until we call the stop() method. To be complete, we should manually dereference the thread object after we call the stop() method. However, this is necessary only to free the memory that stores the thread Object. The threading automatically releases any thread-specific resource (including those tied to the os) after the thread has completed or stopped whether or not we dereference the object

Dereferencing a thread object for a running thread is also not a problem. The threading system keeps references to all threads that are running in the system. This is needed in order to support the currentThread() and enumeration() methods of the Thread class. The garbage collector will not be able to collect the thread object until the threading system also dereferences the object, which won't happen until the thread is no longer alive.

class MyThread extends Thread {

 MyThread(String name) { // Constructor
         super(name);
         }

 public void run() {  // override the run method
   try {
         while (true) { // sleep and print
           sleep(500);
           System.out.println(getName() + ": is running");
                      }
   } catch (ThreadDeath ouch) { // Catch killing of this thread
       // Add any actions you want done before thread dies
       System.out.println(getName() + " is being killed");
       throw(ouch);  
           // rethrow the error so thread dies
   } catch (InterruptedException e) {} 
   }
 }

public class CatchDeath {

 static public void main(String s[]) {

    MyThread Thread_a;  // Define a Thread

    // Create the thread
    Thread_a = new MyThread("Thread a"); 

    System.out.println("Starting the thread...");
        
    Thread_a.start();  // Start the thread

    // Sleep for a bit
    try {
            Thread.sleep(2000);
    } catch (InterruptedException e) {}

    // Stop the thread
    System.out.println("Stopping the thread...");
    Thread_a.stop();
    }
 }

In foo In foobar 30 Leaving foobar Leaving foo In foobar 50 Leaving foobar

public void GetBusyFlag() { while(true) { synchronized (this) { if (busyflag == null) { busyflag = Thread.currentThread(); break; } } try { Thread.sleep(100); } catch (Exception e) {} } }

It is possible to use only the synchronized block mechanism, even when we need to synchronize the whole method.

Picking the whole method is the simplest to use, but it is possible to then have a deadlock condition due to the scope being too large. It may also be inefficient to hold a lock for the section of code where it is actually not needed.

// This example is from the book _Java Threads_ 
// Written by Scott Oaks and Henry Wong.
// Copyright (c) 1997 O'Reilly & Associates.
// You may study, use, modify, and distribute 
// this example for any purpose.
// This example is provided WITHOUT WARRANTY 
// either expressed or implied.
 
// Sample BusyFlag -- Chapter 4, p. 74.  This is the fully 
// functional BusyFlag class.
 
public class BusyFlag {
  private Thread busyflag = null;
  private int busycount = 0;
 
  public synchronized void getBusyFlag() {
       while (tryGetBusyFlag() == false) {
            try {
                wait();
            } catch (Exception e) {}
       }
  }
 
  public synchronized boolean tryGetBusyFlag() {
       if (busyflag == null) {
            busyflag = Thread.currentThread();
            busycount = 1;
            return true;
       }
      if (busyflag == Thread.currentThread()) {
            busycount++;
            return true;
       }
       return false;
  }
 
  public synchronized void freeBusyFlag() {
       if (getBusyFlagOwner() == Thread.currentThread()) {
            busycount--;
            if (busycount == 0) {
                 busyflag = null;
                 notify();
            }
       }
  }
 
  public synchronized Thread getBusyFlagOwner() {
       return busyflag;
  }
}