Should we ever extend Thread?

From the Sun tutorial:
http://java.sun.com/docs/books/tutorial/essential/threads/index.html
You have now seen two ways to provide the run method:
- Subclass the Thread class and override the run method
- Provide a class that implements the Runnable interface...
There are good reasons for choosing either of these options over the other...
I can't figure out any good reasons to ever extend Thread vs. implementing Runnable. Anybody have any ideas?

Actually, I always just extend thread so I can call
start() on it directly. It's a matter of preference.
A good reason to use Runnable is when you are
e already extending another class, Java doesn't do
multiple inheritance (thank god!).Perhaps, but there's a valid argument that this is conceptually wrong. You should extend a class if and only if your derived class is primarily of that type.
So if you want to create a VeryLowPriorityThread class, it's perfectly reasonable to derive from Thread. Whereas if you are creating a NamedPipe class (which must receive and serve data on a background thread of execution) it would be quite mad to pretend it's a thread, when it's merely Runnable.
Saving typing is not one of the purposes of object orientation, even if it often happens to achieve that end. So the difference between:
new Thread(new MyRunnable()).start();and
new MyRunnable().start();Is not justification for corrupting your design.
Dave.

Similar Messages

Creating array of objects of class which extends Thread

getting NullPointerException
can i not create thread array this way?
class sample extends Thread
{ int i,id;
public sample(int c)
   { id=c;
public void run()
{ for(i=0;i<6;i++)
     System.out.println("Thread "+id+" "+i);
public class thread extends Frame implements ActionListener
{ Button b1;
   sample s[];
   thread()
   { for(int i=0;i<2;i++)
          s=new sample(i);
     setLayout(new FlowLayout());
     b1=new Button("OK");
     add(b1);
     b1.addActionListener(this);
     public void actionPerformed(ActionEvent e)
     {   b1.setEnabled(false);
          for(int i=0;i<2;i++)
          { s[i]=new sample(i);
          s[i].start();
     public static void main(String args[])
     { thread t1=new thread();
     t1.setVisible(true);
     t1.setSize(150,150);

You need:
sample [] s = new sample[2];However
1) You should get into the habit that class names start with capital letters, variable and field names with lower case.
2) It's not a good idea to extend Thread, make a class which implements the Runnable interface and hook a standard Thread object to that.

Performance wise which is best extends Thread Class or implement Runnable

Hi,
Which one is best performance wise extends Thread Class or implement Runnable interface ?
Which are the major difference between them and which one is best in which case.

Which one is best performance wise extends Thread Class or implement Runnable interface ?Which kind of performance? Do you worry about thread creation time, or about execution time?
If the latter, then don't : there is no effect on the code being executed.
If the former (thread creation), then browse the API Javadoc about Executor and ExecutorService , and the other execution-related classes in the same package, to know about the usage of the various threading/execution models.
If you worry about, more generally, throughput (which would be a better concern), then it is not impacted by whether you have implemented your code in a Runnable implementation class, or a Thread subclass.
Which are the major difference between them and which one is best in which case.Runnable is almost always better design-wise :
- it will eventually be executed in a thread, but it leaves you the flexibility to choose which thread (the current one, another thread, another from a pool,...). In particular you should read about Executor and ExecutorService as mentioned above. In particular, if you happen to actually have a performance problem, you can change the thread creation code with little impact on the code being executed in the threads.
- it is an interface, and leaves you free to extend another class. Especially useful for the Command pattern.
Edited by: jduprez on May 16, 2011 2:08 PM

Extends Thread and Remote

Hi.
I have a server that creates a Thread to comunicate to other server (a secondary server) using sockets.
public class Server extends Thread {
}I need to use RMI now but I can't extend Thread and Remote.
What can I do?
Thanks

Implement the Runnable interface and extend the Remote class. This way you can Construct A thread and pass it an instance of your Runnable interface. ie.
class MyClass extends Remote implements Runnable{
// put what ever methods you need and implment the run method
// for Runnable interface
now you can do this.
Thread myThread = new Thread(new MyClass());
myThread.start(); // to kick it off

Extends Thread versus Implements Runnable... difference?

I've seen them both used and to the naked eye it seems to be pretty much the same (besides the execution).
Can anyone tell me the major differences between the two methods of multi-threading and how/if one is better?
Do you ever make a deliberate choice to use Extends over Implements (or vice versa) for a specific task?

For the record, I've normally used extends Thread, and
seeing the light that in doing that, I can only extend
one class, I'm looking into the alternative.
Are...
Thread t1 = new Thread(new myRunnableThread());
Thread t2 = new Thread(new myRunnableThread());
t1.start();
t2.start()
and...
MyExtendedThread t1 = new MyExtendedThread();
MyExtendedThread t2 = new MyExtendedThread();
t1.start();
t2.start();
equivalent?
equivalent meaning that they are equally fast? I'd say no, because in the first example you are creating a thread and a runnable, in the second you are only creating a thread.
>
Additionally, consider -
public class myExtendedThread extends Thread {
ServerSocket ServiceConnectSocket = new
ServerSocket(4000);
NotificationListener mainThread;
public myExtendedThread(NotificationListener
_mainThread) {
mainThread = _mainThread;
public void run() {
      while(true)
             if (ServiceConnectSocket != null)
                 return;
             try
                 Thread.sleep(5000);
ServiceConnectSocket = new
ectSocket = new Socket(host, port);
                 ServiceConnectSocket.close();
                 mainThread.serviceReady();
             catch (Exception e)
>
This thread basically tries to connect to a socket,
and when it does, it closes the socket it made,
notifies another thread (passed in at the constructor)
and returns.
My question is on what happens when Threads return.
When this thread returns... what happens exactly?
What if mainThread.serviceReady restarted that
t thread? Would it start a NEW thread or just re-run
the run() of the old one?
Once a thread returns, how long before Garbage
Collection will free up the memory it used?
When the run method returns, the thread is dead. It is not reused automatically. You have to implement some type of thread reuse like my code above.
I would assume that the normal GC rules apply. Each JVM can decide to cleanup the thread whenever it feels like it.

I purchased and downloaded Acrobat Pro XI and have installed it. I want to create a reinstall disk should I ever need it. I planned on using a DVD. I'm running Win 7 Pro w/SP1.

I purchased and downloaded Acrobat Pro XI and have installed it. I want to create a reinstall disk should I ever need it. I planned on using a DVD. I'm running Win 7 Pro w/SP1.

Hi halb10567672,
You can download the setup file again from this Link (Download Acrobat products | Standard, Pro | XI, X ) and Burn it to a DVD Disc using Windows Explorer.
Please revert back for any further query or assistance.
Regards,
Rahul

Calls to methods in a class that extends Thread

Hello,
I have some code that I am initiating from within an ActionListener that is part of my programs GUI. The code is quite long winded, at least in terms of how long it takes to perform. The code runs nicely, however once it is running the GUI freezes completely until operations have completed. This is unacceptable as the code can take up to hours to complete. After posting a message on this forum in regard to the freezing of the GUI it was kindly suggested that I use multi-threading to avoid the unwelcome program behaviour.
The code to my class is as follows:
public class FullURLAddress
private boolean success_flag = true;
private BufferedReader iN;
private Document dT;
private EditorKit kT;
private Element lmNt;
private ElementIterator lmIterate;
private XURL[] compAddress;
private int countX = 0;           //Tracks Vector vT's size.
private int countY = 0;           //Tracks Vector vS's size.
private int xURLcount = 0;        //Tracks XURL objects instantiated by this FullURLAddress object.
private SimpleAttributeSet simpAtSet;
private String aURL;              //Contains original (Xtended) URL!
private String fileType;
private String indexContent;
private String[] parseURL;
private String[] finalStrings;
private String[] sortStrings;
private URL indexConnect;
private URLConnection iconn;
private Vector vT;            //Stores href information, from targeted URL's HTML souce code.
private Vector vS;            //Stores sorted HREF info ".jpg" and ".gif" only (no: png, tiff, etc).
public FullURLAddress(String aURL)
    this.aURL = aURL;
    try{
      indexConnect = new URL(aURL);
      iconn = indexConnect.openConnection();
      iN = new BufferedReader(new InputStreamReader(iconn.getInputStream()));
        /* Document creation, analysis objects instantiated */
      vT = new Vector();
      vS = new Vector();
      kT = new HTMLEditorKit();
      dT = kT.createDefaultDocument();
      dT.putProperty("IgnoreCharsetDirective", Boolean.TRUE);
        /* Iterate through document and store all HREF values */
      kT.read(iN, dT, 0);
      lmIterate = new ElementIterator(dT);
      while((lmNt = lmIterate.next()) != null)
        simpAtSet = (SimpleAttributeSet)lmNt.getAttributes().getAttribute(HTML.Tag.A);
        if(simpAtSet != null)         //As long as there are A tags to be read...
          vT.addElement(simpAtSet.getAttribute(HTML.Attribute.HREF));
          countX++;//Tracks number of HREF occurences occur, giving better control of the Vector.
    }catch(MalformedURLException e){
      success_flag = false;
      System.out.println("FullURLAddress object has encountered a "+
                         "MalformedURLException at: "+aURL);
    }catch(IOException e){
      e.getMessage();
      success_flag = false;
    }catch(BadLocationException e){
      e.getMessage();
      success_flag = false;
    /* Searches through all HREF attributes that are now stored in Vector
       vT for occurences of the character string ".htm" */
    sortStrings = new String[countX];
    for(int i=0;i<countX;i++)
      sortStrings[i] = (String)vT.elementAt(i); //Vector Strings transfered into array.
      if(sortStrings.endsWith("gif")) // Does href value end with ".jpg"?
vS.addElement(sortStrings[i]); // If so add it to the sorted Vector vS.
countY++;
if(sortStrings[i].endsWith("GIF"))
vS.addElement(sortStrings[i]);
countY++;
if(sortStrings[i].endsWith("jpg")) // Does href value end with ".jpg"?
vS.addElement(sortStrings[i]); // If so add it to the sorted Vector vS.
countY++;
if(sortStrings[i].endsWith("JPG"))
vS.addElement(sortStrings[i]);
countY++;
finalStrings = new String[countY];
for(int j=0;j<countY;j++)
finalStrings[j] = (String)vS.elementAt(j);
public int getCount()
return countY; //Returns number of instances of htm strings
} //ending with either "jpg" or "gif".
public String[] xurlAddressDetails()
return finalStrings;
I have changed the above code to make use of multithreading by making this class extend Thread and implementing the run() method as follows:
public class FullURLAddress extends Thread
private boolean success_flag = true;
private BufferedReader iN;
private Document dT;
private EditorKit kT;
private Element lmNt;
private ElementIterator lmIterate;
private XURL[] compAddress;
private int countX = 0;           //Tracks Vector vT's size.
private int countY = 0;           //Tracks Vector vS's size.
private int xURLcount = 0;        //Tracks XURL objects instantiated by this FullURLAddress object.
private SimpleAttributeSet simpAtSet;
private String aURL;              //Contains original (Xtended) URL!
private String fileType;
private String indexContent;
private String[] parseURL;
private String[] finalStrings;
private String[] sortStrings;
private URL indexConnect;
private URLConnection iconn;
private Vector vT;            //Stores href information, from targeted URL's HTML souce code.
private Vector vS;            //Stores sorted HREF info ".jpg" and ".gif" only (no: png, tiff, etc).
public FullURLAddress(String aURL)
    this.aURL = aURL;
public void run()
    try{
      indexConnect = new URL(aURL);
      iconn = indexConnect.openConnection();
      iN = new BufferedReader(new InputStreamReader(iconn.getInputStream()));
        /* Document creation, analysis objects instantiated */
      vT = new Vector();
      vS = new Vector();
      kT = new HTMLEditorKit();
      dT = kT.createDefaultDocument();
      dT.putProperty("IgnoreCharsetDirective", Boolean.TRUE);
        /* Iterate through document and store all HREF values */
      kT.read(iN, dT, 0);
      lmIterate = new ElementIterator(dT);
      while((lmNt = lmIterate.next()) != null)
        simpAtSet = (SimpleAttributeSet)lmNt.getAttributes().getAttribute(HTML.Tag.A);
        if(simpAtSet != null)         //As long as there are A tags to be read...
          vT.addElement(simpAtSet.getAttribute(HTML.Attribute.HREF));
          countX++;//Tracks number of HREF occurences occur, giving better control of the Vector.
    }catch(MalformedURLException e){
      success_flag = false;
      System.out.println("FullURLAddress object has encountered a "+
                         "MalformedURLException at: "+aURL);
    }catch(IOException e){
      e.getMessage();
      success_flag = false;
    }catch(BadLocationException e){
      e.getMessage();
      success_flag = false;
    /* Searches through all HREF attributes that are now stored in Vector
       vT for occurences of the character string ".htm" */
    sortStrings = new String[countX];
    for(int i=0;i<countX;i++)
      sortStrings[i] = (String)vT.elementAt(i); //Vector Strings transfered into array.
      if(sortStrings.endsWith("gif")) // Does href value end with ".jpg"?
vS.addElement(sortStrings[i]); // If so add it to the sorted Vector vS.
countY++;
if(sortStrings[i].endsWith("GIF"))
vS.addElement(sortStrings[i]);
countY++;
if(sortStrings[i].endsWith("jpg")) // Does href value end with ".jpg"?
vS.addElement(sortStrings[i]); // If so add it to the sorted Vector vS.
countY++;
if(sortStrings[i].endsWith("JPG"))
vS.addElement(sortStrings[i]);
countY++;
finalStrings = new String[countY];
for(int j=0;j<countY;j++)
finalStrings[j] = (String)vS.elementAt(j);
/* What happens with these methods, will they need to have their
own treads also? */
public int getCount()
return countY; //Returns number of instances of htm strings
} //ending with either "jpg" or "gif".
public String[] xurlAddressDetails()
return finalStrings;
Are there any special things that I need to do in regard to the variables returned by the getCount() and xurlAddressDetails() methods. These methods are called by the code that started the run method from within my GUI. I don't understand which thread these methods are running in, obviously there is an AWT thread for my GUI and then a seperate thread for my FullURLAddress objects, but does this new thread also encompass the getCount() and xurlAddressDetails() methods?
Please explain.
This probably sounds a little wack, but I don't understand what thread is responisble for the methods in my FullURLAddress class aside of course from the run() method which is obvious. Any help will be awesome.
Thanks
Davo

Threads are part of code that allows you to run multiple operations "simultaneously". "Simultaneously", because threads are not run actually simultaneously in any one-CPU machine. Since you most propably have only one CPU in your system, you can only execute one CPU instruction at time. Basically this means that your CPU can handle only one java-operation at time. It does not matter if you put some code in thread and start it, it will still take up all CPU time as long as the thread runs.
So you would need a way to let other threads run also, for that purpose thread contains a yield feature that allows you to give time for other threads to run.
http://java.sun.com/j2se/1.4.1/docs/api/java/lang/Thread.html#yield()
You need to use thread's yield() method in your thread code, in a place you want to give other threads time to run. Also bear in mind that if you yield your first thread run to allow second thread to run, you also need to add yield to the second thread also. If you don't, after yielding the first thread, the second thread will eat up all CPU time until it finishes, thus meaning the rest of your first thread will be run after second thread is done.
One good place to execute yield() is usually at the end of a loop, for example 'for' or 'while' loop. This way you prevent for example while-deadlocks.
Here is a java thread tutorial, worthy reading:
http://java.sun.com/docs/books/tutorial/essential/threads/

Should Value Objects Extend SkinnableComponent?

If you have a value object called Product.as, received from a server lets say via AMFPHP should this VO extend SkinnableComponent so you display it directly? What are the advantages and disadvantages?
Here is a very simple example of Product.as Class:
public class Product
        public var id:Number;
        public var name:String;
        public var brand:String;
        public var price:Number;
        public var description:String;
        public var inStock:Boolean;
        public var imageURL:String;
        public function Product()
Now It would be useful if this VO extended SkinnableComponent you could create a skins to show the product information in different ways e.g. just a price tag (showing price), a product thumbnail (showing image, name, brand) or show all the products details.
So you would end up with ProductPriceTagSkin.mxml, ProductThumbnailSkin.mxml, ProductDetailsSkin.mxml + the Product.as - this is all well and good, isn't it?
Well what happens if you want to use the price tag on its own, without the Product class? Ah problem - because its just a skin its tied to the HostComponent Product class.
OK so lets take another route, the Product class does not inherit from SkinnableComponent instead lets say it inherits from EventDispatcher.
So now we have to create separate components/classes for each "view" and a skin for each of these. e.g. What was the ProductThumbnailSkin.mxml now becomes ProductThumbnailSkin.mxml but this has a HostComponent of ProductThumbnail.as which has the properties of; imageURL, name, brand and extends SkinnableComponent.
OK so we can now pass the properties from the Product.as to the ProductThumbnail.as which has a skin of ProductThumbnailSkin.mxml. As the ProductThumbnail.as is not tied to Product.as you can use it in other projects or on its own without a Product.
Now this all seems great but you have to create extra files bit annoying but you gain flexibility for your pains. Now the above example, I think seems fairly doable but what happens when we come to do the ProductDetail.as and ProductDetailsSkin.mxml. ProductDetails.as is going to have the exact same properties as Product.as so now we have come full circle why not just make Product.as extend SkinnableComponent and have 3 skins ProductPriceTagSkin.mxml, ProductThumbnailSkin.mxml, ProductDetailsSkin.mxml? But now we are back at the catch of loosing flexibility and re-use.
I keep flitting back and forth between which method would be the best set-up to allow flexibility and maintainability, what is everybody else's thoughts? Are the different methods? I hope my twittering's make sense?
Thanks,
James

Is it better to either initialize a property with a value
(like spaces for a String, or current date for a Date)
or to keep the property null until the property is
initalized by an object calling its mutator method??Either, it depends on your requirements.
However, typically include a number of states within my Dao. e.g
abstract public class AbstractValueObjectTemplate {
   private State isNew = new State( true ) ;
   private State isLoaded = new State( false ) ;
   private State isDirty = new State( false ) ;
   private State isDeleted = new State( false );
   /** an Inner Class for holding the Dao's state. **/
   private class State {
      private boolean state = false;
      public State(boolean state) {
           this.state = state ; }
      /** set the state to true. */
      public void set() {
        state = true; }
      /** clear the state, set state to false. */
      public void clear() {
        state = false; }
      /** test the current state to see if it is set to true.
       * @return return true if the state is set.
      public boolean isSet() {
        return state; }
      /** Test the current state to see if it is set to false.*/
      public boolean isClear() {
        return( !state ) ; }
// ... Dao Body ...

Assigning ThreadGroup to a Class that Extends Thread

How can i assign a thread group to a class running as a thread that extends thread without changing the class to implement Runnable?
An Example of the application format:
public class Application implements Runnable
private ThreadGroup main = new ThreadGroup("Main");
private Thread mainThread = null;
public Application()
public void start()
if (mainThread == null)
mainThread = new Thread(main,"main")
mainThread.start();
public void run()
Thread current = Thread.currentThread();
while(current != null)
while(something to do)
AThread a = new AThread();
a.start();
String aData = a.getData();
BThread b = new BThread(data);
b.start();
String bData = b.getData();
class AThead extends Thread
public AThread()
//What to do with AThread to assign it to a thread group?
public void run()
Basically the application works form a main constructor class running the application class as a thread. The application class will then launch AThread and BThread as subthreads. I would like to be able to count how many of each type of thread is running for the AThread and BThread. I tried using AThread and BThread implementing Runnable to create a thread under a group but it wouldn't work. The application class needs to get information from the AThread and BThread threads once the thread was done, but if the AThread and BThread was implementing Runnable, the Applicaiton Class can't get the data or run methods. Is there some way i can assign what thread group AThread and BThread will run as in thier class files and not the Application class?

See: http://java.sun.com/j2se/1.4/docs/api/java/lang/Thread.html#Thread(java.lang.ThreadGroup, java.lang.String)
I think this does what you want:
public class Application implements Runnable
private ThreadGroup main = new ThreadGroup("Main");
private ThreadGroup aThreads = new ThreadGroup("AThreads"); // Added a thread group for all AThread objects
private Thread mainThread = null;
public Application()
public void start()
if (mainThread == null)
    mainThread = new Thread(main,"main")
    mainThread.start();
public void run()
    Thread current = Thread.currentThread();
    while(current != null)
      while(something to do)
        AThread a = new AThread(aThreads); // Create an AThread that will belong to aThreads ThreadGroup
        a.start();
        String aData = a.getData();
        BThread b = new BThread(data);
        b.start();
        String bData = b.getData();
class AThead extends Thread
public AThread(ThreadGroup group)
    super(group, "AThread"); // This will make a new Thread that belongs to ThreadGroup group, see link above
public void run()
}

Implementing Runnable interface Vs extending Thread class

hi,
i've come to know by some people says that Implementing Runnbale interface while creating a thread is better option rather than extending a Thread class. HOw and Why? Can anybody explain.?

Its the same amount of programming work...
Sometimes it is not possible to extend Thread, becuase your threaded class might have to extend something else.
The only difference between implementing Runnable and extending Thread is that by extending Thread, each of your threads has a unique object associated with it, whereas with Runnable, many threads share the same object instance.
http://developerlife.com/lessons/threadsintro/default.htm#Implementing

Extends thread and Runnle Interface

In java there 2 ways to create thread
1.Extending thread
2.implements runnable interface
What is difference between the 2 approaches? which one to use where?

public class ThreadTest extends Thread {
public void run() {
public static void main(String[] args) {
    ThreadTest tt = new ThreadTest();
    tt.start();
public class ThreadTest extends Runnable {
public void run() {
public static void main(String[] args) {
    ThreadTest tt = new ThreadTest();
    Thread t = new Thread(tt);
    t.start();
}The difference is how you start the thread when you code it. if you extend Thread, you can call its run method directly. When you extends Runnable, A wrapper is needed to start the thread.
The Runnable approach is used when your class is extending another class (eg. JFrame). Since Java do not support multiple inheritance, you can write something like public class MyProg extends JFrame implements Runnable, and still have a thread.

Implements Runnable vs extends Thread

Hello,
Why do we call method run() in a Runnable class a thread? (at least my textbook implies such concept)
If thread is an independent process, which runs on its own - then it's not about Runnable.run().
public class RunnableThread implements Runnable
    public void run()
        for (int i=0; i<100000; i++)
            if (i%50000 == 0)
            System.out.print(i+" ");
    public static void main (String args[])
        System.out.println("Before thread");
        new RunnableThread().run();
        System.out.println("Thread started");// this line is executed only after
        // run() returns, not like with "true" threads, where execution course
        //doesn't wait for start() to return
}Or should I consider run() a regular (non-thread) method needed only to bypass extends restrictions?

Why do we call method run() in a Runnable class a
thread? We don't.
(at least my textbook implies such concept)Perhaps you could post what your textbook says, and we can decipher it for you.
If thread is an independent process, which runs
on its own - then it's not about Runnable.run().Don't know what you mean by it being "about" Runnable.run()?
Runnable.run is the method that gets executed when a thread is started.
Or should I consider run() a regular (non-thread)
method needed run() is a regular method. It happens to be one that is declared in the Runnable interface and is called by an executing thread. In your example code, you use just call run as you would any other method, so it acts just like any other method. To run it in a separate thread, you should call start() on the thread, not run(). The Thread object will then enter the waiting state and will call run() itself at the appropriate time.

We are using extends thread and implements runnable which class first calli

hi

Yes, the language allows it, but your JSL quote is the 3rd edition, and Java 1.4 is based on the 2nd edition (the 2nd edition of the JSL does not go into such a deep explanation of the example shown, so thanks for that pointer). In any case, since the JSL does not address my specific issue, it is only superficially relevant (IMHO). The language allows it, but the behavior is unpredictable. I think that's what is sticking in my craw. I'm not sure what the behavior should be, but if I had to, I would propose that the behavior should not change when I change the inheritance qualifiers (again, in this particular case), but there may be other considerations.
HibernateUtil is a snippet that can be found in the Hibernate tutorial/reference at [http://www.hibernate.org/hib_docs/v3/reference/en/html/tutorial.html|http://www.hibernate.org/hib_docs/v3/reference/en/html/tutorial.html]
The basic idea is a cached session factory, because session factories are expensive to build. We use multiple databases, so our incarnation of HibernateUtil compares the requested database to the one in a static factory variable. If they match, that factory is used. If they don't match, the thread switches to the requested factory and creates sessions from it.
The odd thing is that with the aforementioned inheritance "typo", it either detects that the requested database is the same as the one in the static factory (which is not true), or it returns the wrong factory (which is wrong). I want to emphasize that no other code changes were made (zero, zip, none, really, I mean it), and lots of other classes extend C1 (from the example) and they have never had this problem.

Should I use a thread and (in this case) how?

Hi:
I have a Swing frame (frameA) and on which there is a button; if I double click it,
it will bring up a second frame (frameB). On frameB, I will select a new button name
from a combobox, and click "DONE" button, and frameB would change the name of the
button on frameA to this new name I selected. And frameB would disappear as well.
I am thinking of using another thread for painting frameB, because I don't know how long
it would take for frameB to load up, and I don't want to block up the event-dispatching thread
on frameA.
However, since frameB uses another thread, and frameB also has an ActionListener
associated with the DONE button, i am not sure how to make the thread stay alive
so that it could check whether the ActionEvent is fired. So, in this case, is it necessary to use
another thread to do the job? Or should I just use the same event-dispatching thread?
Or is there another whole new approach much better?
Thanks

Quite simply, I wouldn't bother threading it.
If you load, link and instantiate the pop-up frame (actually I'd use a Dialog here) before you trigger the pop-up, the reaction is more or less instant. The execution of th parent frame will continue after the pop-up has been made visible, so any way you cut it, you are going to get a brief pause in the parent UI while the pop-up is shown - you may as well have it when the button is clicked.
Hope this helps.--
<sig> http://www.itswalky.com http://www.crfh.net </sig>

Threads: implement runnable or extend Thread. Which is better?

I want to know which way is better, as I want to do some work in threads.
Thanks,
Virum

I want to know which way is better, as I want to do
some work in threads.
Thanks,
VirumOne reason for implementing runnable can be that java doesnot allow multiple inheritance so by implementing runnable you can, at the same time, extend another class.
Another reason though not recommended and not good programming practice is that although you cannot restart a dead thread, if you use runnables, you can submit the old runnable instance to a new thread, thus practically starting a thread more than once.

Should we ever extend Thread?

Similar Messages

Maybe you are looking for