Will subsequent calls to an object running in a thread run in the thread?

Question

Hi,
If I start a thread with an empty run method and then make a call to the object that I started in the thread, will the method call run in the other thread? For example:
class ThreadClass implements Runnable {
    public void someMethod() {
    public void run() {
class ThreadCaller {
    private ThreadClass threadClass;
    public ThreadCaller() {
        threadClass = new ThreadClass();
        Thread thread = new Thread(threadClass);
        thread.start();
    public blah() {
        threadClass.someMethod();
}Will the method call in blah() run in the same thread as ThreadCaller, or will it run in the thread that was started in ThreadCaller's constructor?
Thanks,
Dan

Answer 1

Djaunl wrote:
vanilla_lorax wrote:
Djaunl wrote:
Is there a way to keep the thread alive until the object that started the thread is terminated,Objects don't get terminated. What do you mean?I want the thread to stay alive indefinitely until I arbitrarily terminate it makes more sense. The thread will stay alive until its run method completes. The canonical approaches are
public void run() {
  while (!Thread.interrupted()) { // NOT isInterrupted()
    // do stuff
    // if you need to catch InterruptedException, do this:
    try {
    catch (InterruptedException exc) {
      Thread.currentThread().interrupt();
}And then from another thread, call theAboveThread.interrupt() when it's time to stop. Read the docs in interrupt(), interrupted(), the interrupt flag, etc.
OR
while (!done()) {
  // do stuff
}and then another thread calls setDone(true) or somesuch when it's time to stop. Note that all access to done--both get and set--must be synchronized, or done must be declared volatile. Also note that you may still have to handle interrupts, so you may have some repeated code with this approach--testing both done() and interrupted().
Let me give the end-goal of this.
Currently, I have a "main" thread which the user can input commands into, and another thread which occasionally runs in the background. When I want something to run in the background, I just create a new thread. However, I figured it'd be more efficient to have one thread running in the background to do something as opposed to spawning hundreds of new threads to do the same task over and over. If the task happens VERY frequently and what it does is VERY small and quick, then the overhead of thread creation may make this a valid approach. Otherwise, don't overcomplicate it. Since you're new to threads, first get it working where you spawn one thread for each background task. Then move on to thread pooling. Look into ThreadPoolExecutor and related classes.
http://java.sun.com/javase/6/docs/api/java/util/concurrent/ThreadPoolExecutor.html