这样可以处理线程和阻塞队列吗？

Question

I was wondering if it was okay that you give a thread access to an instance of a class so you can perform operations on certain members/variables of that class.

For example, I have both a main thread and a thread. I'm giving the second thread access to the instance of the main class so I can perform an operation on x.

However, what if at some point in the future I decide to do operations on x in the main thread? Or just simply reading from x. What if both the other thread and the main thread want to read x at the same time?

Is this at all okay by the way I have it structured in my code to do?

package test;

import java.lang.Thread;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class AThread extends Thread {

    Test test;

    AThread(Test test) {
        this.test = test;
    }
    BlockingQueue<String> queue = new LinkedBlockingQueue<String>();

    public void run() {
        String msg;
        while ((msg = queue.poll()) != null) {
            // Process the message
            //System.out.println(msg); //should print "hello"
            if (msg.equals("up")) {
                test.setX(test.getX()+1);
                System.out.println(test.getX());
            }
        }
    }
}

public class Test {
    AThread aThread;
    private int x = 5;

    void setX(int x){
        this.x = x;
    }

    int getX(){
        return x;
    }

    Test() throws InterruptedException{
        System.out.println("MainThread");
        aThread = new AThread(this);
        aThread.start();
        while (true) {
            aThread.queue.put("up");

        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Test();
    }
}

And not just the member 'x', but also there could be more members in class "Test" that I'd want to be able to perform operations on such as reading/writing.

Is this an okay structure to do so? If not, what should be fixed?

Answer 1

There are several problems with your code.

Consider this line:

    aThread = new AThread(this);

It is always a bad idea to pass this somewhere in a constructor. And this has nothing to do with the threads... yet. The reason is that the 'somewhere' may call a method on this , and the method could be overridden in a subclass whose constructor wasn't called yet, and it may end up in disaster because that override may use some of the subclass fields that aren't initialized yet.

Now, when threads come into the picture, things get even worse. A thread is guaranteed to have correct access to a class instance that was created before the thread is started. But in your case, it isn't created yet, because the constructor is not finished yet! And it's not going to finish anywhere soon because of the infinite loop below:

    while (true) {
        aThread.queue.put("up");

    }

So you have an object creation running in parallel to a startup of a thread. Java doesn't guarantee that the thread will see the initialized class in such case (even if there was no loop).

This is also one of the reasons why starting threads in constructors is considered a bad idea. Some IDEs even give a warning in such cases. Note that running infinite loops in constructors is probably a bad idea too.

If you move your code into a run() kind of method and do new Test().run() in main() , then you code will look fine, but you are right to worry about

However, what if at some point in the future I decide to do operations on x in the main thread?

The best idea is for the main thread to forget about the object right after it is passed to the thread:

public static void main(String[] args) throws InterruptedException {
    AThread aThread = new AThread(new Test());
    aThread.start();
    while (true) {
        aThread.queue.put("up");
    }
}

Answer 2

However, what if at some point in the future I decide to do operations on x in the main thread? Or just simply reading from x. What if both the other thread and the main thread want to read x at the same time?

Any time you are sharing information between two threads, you need to provide for memory synchronization. In this case, if you make int x be volatile int x then your code should work fine. You should read the Java tutorial on the subject .

However, if the thread is doing more complex operations, as opposed to just setting or getting x , then you may need to make the method be synchronized or otherwise provide a mutex lock to make sure that the 2 threads don't overlap improperly.

For example, if you need to increment the value of x , a volatile won't help since increment is actually 3 operations: get, increment, and set. You could use a synchronized lock to protect the ++ or you should consider using an AtomicInteger which handles incrementAndGet() methods in a thread-safe manner.

@Segey's answer gives some great feedback about the rest of your code. I'll add one comment about this code:

    while (true) {
        aThread.queue.put("up");
    }

You almost never want to spin like this. If you want to do something like this then I'd add some Thread.sleep(10) or something to slow down the adding to the queue or make the queue bounded in size. It is likely that you are going to run out of memory spinning and creating queue elements like this.