一个有自己线程的类是否也可以有其他类使用的静态方法？

Question

I am new to Java and so apologies if this question come off as ignorant.

Let's say I have a class A that implements Runnable, an instance of the class is created in main and given its own thread. Let's say the class holds the blueprint for a Town object, and this town has inhabitants. Class Town is able to create new inhabitants. It is also able to print the current layout of the town repeatedly.

This class then has a run method which performs a task repeatedly (refresh town layout). The class also has static methods which I want to be used by other classes (create new inhabitant).

I now have class B which has the blueprint for an inhabitant. Therefore there are many instances of that class which run in their own thread, and want to use the static method of class B to reproduce (ie create new inhabitant).

Assume now that both class A and B objects have their threads running. If an object of class B (inhabitant) decides to reproduce (use one of the class B static methods), will this result in class A object thread being interrupted?

Ie when an inhabitant wants to reproduce, will the actions of the reproduce static method be in the inhabitants thread?

I have read about multithreading in Java but the topic is difficult for me to understand when actually implementing it. Any advice about multithreading in general would be very helpful. Thank You in advance.

Answer 1

Assume now that both class A and B objects have their threads running. If an object of class B (inhabitant) decides to reproduce (use one of the class B static methods), will this result in class A object thread being interrupted?

No. There is no connection between the class or instance a method is part of, and the thread on which it runs. The only association between a thread and a method is that when you call the method, it's run on the currently-executing thread. If A 's run is running on thread 4452 and you call B.whatever() on thread 4127, it has no effect whatsoever on thread 4452 unless they both try to synchronize on the same object.

Answer 2

Let's say I have a class A that implements Runnable, an instance of the class is created in main and given its own thread.

The idea of giving a class a thread has no meaning in Java. You give a Thread object a Runnable instance, and when you start() the thread, it executes the given instance's run() method. Once the thread is running, there is no difference between how it executes the given run() method, and how your program's main thread executes your program's main(String[] args) method.

...when an inhabitant wants to reproduce, will the actions of the reproduce static method be in the inhabitants thread?

The only things that are in a thread are the local variables of the methods that the thread calls.

An object can never be in a thread because an object can never be in a variable: Objects are always in the heap, and variables only hold references to them.

So, what you describe basically is two different threads, each executing different methods, and both of them operating on the same objects with complete disregard for one another.

That's usually a Bad Thing.

You'll need to insure that the threads synchronize the operations that they perform on shared objects to avoid messing up each other's work. A good starting place to learn is to work your way through the Java Concurrencty Tutorial: http://docs.oracle.com/javase/tutorial/essential/concurrency/

When you're ready to go deeper, the book "Java Concurrency in Practice" is a good next step: https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/

Answer 3

Usually methods and other code is always executed in the caller thread unless manually redirected in another thread context.

Since you're speaking of static methods they cannot access class objects anyway, if you change class behaviour in your static methods that might be not a good idea and maybe you should not use so many static methods unless for some constant values and then inter thread access is non problematic in most cases. But that depends on your code and what you do in those methods...

In Java you can also use the volatile modifier, if you need to have write access to some variables or class members from multiple threads or use a custom synchronized { ... } block or method.