Java：我是否错过了线程问题？ （线程内的对象）

Question

I'm trying to learn threads in Java. I've followed two different tutorials, but I feel like I'm not really getting the concept. As I understand it, when you create threads, you use the Thread class, and then embedding your own object within the thread. I can do that, but I can't figure out how to access the instance variables within the "embedded" object.

Suppose as a learning exercise, I wanted to create three threads which would go off and do work individually of one another. I could define this object to "drive" the threads:

public class StoogeObject implements Runnable {

    String name;
    int data;

    public StoogeObject(String name, int data){
        this.name=name;
        this.data=data;
    }

    @Override
    public void run() {
        System.out.println("Thread "+this.name+" has this data: "+this.data);
        // Do useful work here
        System.out.println("Thread "+this.name+" is exiting...");
    }

    public String getName(){
        return this.name;
    }
}

Then, in a driver program, I would launch my threads:

public class driver {

    public static void main(String[] args){
        Thread stooge1 = new Thread(new StoogeObject("Larry", 123));
        Thread stooge2 = new Thread(new StoogeObject("Curly", 456));
        Thread stooge3 = new Thread(new StoogeObject("Moe", 789));
        stooge1.start();
        stooge2.start();
        stooge3.start();
        if(stooge1.isAlive())
            System.out.println("From main():  "+stooge1.getName());
    }
}

Output is:

From main():  Thread-0
Thread Larry has this data: 123
Thread Curly has this data: 456
Thread Moe has this data: 789
Thread Larry is exiting...
Thread Curly is exiting...
Thread Moe is exiting...

I was surprised when the stooge1.getName() line in main() produced "Thread-0", not "Larry". I was expecting the getName() method I wrote in stoogeObject.java to override and return the instance variable String name in this instance. Instead, I'm getting the name of the Thread, not the StoogeObject.

So... The stooge1 thread has a StoogeObject within it, but I don't know how to access its instance variables. More significantly, this example makes me wonder if I'm missing the point of threads. If I want my Larry, Curly, & Moe objects to go off and do productive work AND keep their own instance variables, is using threads the wrong way to go here? Should I start over, making these objects into processes?

Answer 1

If you want to access the runnable object that you pass to the thread, you need to keep a reference to it.

Here is an example:

stoogeObject obj = new stoogeObject("Larry", 123);
Thread stooge1 = new Thread(obj);
stooge1.start();
System.out.println(obj.getName());

This will print Larry .

Keep in mind that if the name variable from the stoogeObject instance is changed during the thread's runtime, you'll have to wait for that thread to finish (or finish changing the variable) in order to get the correct value.

You can do that by using join() .

stoogeObject obj = new stoogeObject("Larry", 123);
Thread stooge1 = new Thread(obj);
stooge1.start();
stooge1.join();
System.out.println(obj.getName());

Here the System.out.println(obj.getName()) statement is executed only after the thread is done.

Answer 2

I can't figure out how to access the instance variables within the "embedded" object.

You access them in exactly the same way that you would access the instance variables of any other object.

The "embedded" object, FYI, is called the thread's target or the thread's delegate .

There is nothing special about the target of a Thread . It's just an object.

I was surprised when the stooge1.getName() line in main() produced "Thread-0", not "Larry". I was expecting ... Instead, I'm getting the name of the Thread, not the StoogeObject.

That's because the Thread object and the StoogeObject are different objects.

this example makes me wonder if I'm missing the point of threads.

There are two different ways that threads can be used in a program. The first (which is what people think of more often than not) is that threads are how a Java program can make use of more than one CPU if your platform has more than one CPU. (Virtually all modern servers and workstations have more than one these days, and it's getting to where a lot of cell phones and tablets have more than one as well.) If your platform has, say eight CPUs, then up to eight of your threads may be able to run simultaneously if that many of them are "ready to run."

The second way to use threads in a program is to wait for things. For example, if your program is a server that has to waits for input from each of N clients, and respond to it; you can structure it as N threads that each just listen to and respond to one client. That often makes the code easier to understand. (Just like, it's easier to juggle one ball than it is to juggle N balls).

is using threads the wrong way to go here? Should I start over, making these objects into processes?

Threads can be much more tightly coupled than processes because the threads of a single program all share the same virtual address space (ie, in a Java program, they all share the same heap). Communication between threads usually is one or two orders of magnitude faster than communication between different processes on the same machine.

If you need fine-grained communication between them, then they definitely should be threads. A good rule of thumb is that, an application should never spawn a new process unless there is a really good reason why it should not be just another thread.

Answer 3

I was surprised when the stooge1.getName() line in main() produced "Thread-0", not "Larry". I was expecting the getName() method I wrote in stoogeObject.java to override and return the instance variable String name in this instance. Instead, I'm getting the name of the Thread, not the StoogeObject.

How is this surprising? You never set the thread's name, then you call stooge1.getName() , and stooge1 is the Thread , and you're getting precisely what you asked for: "the name of the Thread".

The only thing the Thread knows about the Runnable that you pass it is that it has a run() method, it doesn't know or care about any other things you've added to your Runnable implementation.

If you want to set the thread's name, either use the Thread constructor that takes a name:

Thread stooge1 = new Thread(new StoogeObject(...), "Thread's Name");

Or set its name later:

stooge1.setName("Thread's Name");

So... The stooge1 thread has a StoogeObject within it, but I don't know how to access its instance variables.

It's up to you to store and manage your StoogeObject s, and Titus' answer covers this nicely. I just wanted to add a bit on top of that to answer your thread name related question.

As a side note: Once you wrap your head around the fundamentals, check out the official high-level concurrency tutorial , particularly the section on "executors". The Java API provides a few really convenient high-level constructs for concurrency that you might find useful in certain situations.