Another thread question...

Question

i am new to working with threads so i really appreciate the help,
anyways, i have a class where i want to launch a method as a thread. This
method takes 2 arguments, both Strings.
I can't come up with a good way to make sure that my method gets the right
parameters for each launch before they are overwritten by the next
incarnation of the primary thread.
     public synchronized void moveSingleFileThreaded(File FileBeingMoved, File FileWeAreMovingTo){
          currentMoveFromFile = FileBeingMoved;
          currentMoveToFile   = FileWeAreMovingTo;
          moverThread = new Thread(this,"Mover" + threadsCurrentlyRunning);
          moverThread.start();in the above code, i need to pass the 2 arguments into the method that will
be threaded. However, that method is called in run(), and since run takes no
arguments there is no way for me to pass them directly. In the above code i
assign the parameters to class data members. However, i am afraid that I
run
the risk of these data members being overwritten before I call this function
again. Am I too worried?
thanks

Answer 1

OK, that makes sense, and that was my first instinct
of what to do. However,
consider the following code:
public class A implements Runnable{
String INFO = null;
private Thread myThread = null;
public void A(String info){
INFO = info;
myThread = new Thread(this,"thread");
myThread.start();
}//end construct
public void run(){
String infoHolder = INFO;  //how can I make SURE
SURE SURE that infoHolder always gets the right
info?
//do something with infoHolder....
}//end class defI know that infoHolder is assigned the value of INFO
in the first line of the
thread, but can I be 100 percent sure this will
execute as expected everytime?
What happens if, for some crazy reason, the thread
gets bumped from
execution on the first line of the run() method, and
when it resumes the
constructor of this class has been called again, with
different info?
INFO and myThread are not static--each instance of "A" will have its own INFO value and its own myThread value. Calling the constructor creates a new instance of "A", so the original instance (that was suspended in your example) is not affected.
Then I
would have an erroneous thread once the original
thread is put back into
action.
The tricky part for me is the fact that I need some
of these threads to sleep
before execution (because I will be copying over a
network and don't want
to overload resources).
Any ideas? thanksAlso, initializing INFO and myThread to null is redundant--the JVM will do that automatically.