1

Question:

A) Write a thread safe class with methods doA(), doB(), doC(). Each of these methods must report the method name, time of invocation, and calling thread name.

B) Write a multi threaded driver that spawns 4 threads, and each thread must call every method – doA(), doB(), doC() – 10 times

I am assuming that it means doA(), doB(), doC() must be safe. But none of them mutate the shared state within the object, they just read object state such as method name, thread name and running time. So, do I need synchronize each method? For the counter within each thread, it is not shared.

I am a little confused here, which of state of the object needs protection?

Edit: Do we need a mechanism to assure the running sequence of doA(), doB(), doC()? I dont think so.

Improve this question

2 Answers 2

Reset to default
3

From the sounds of it, your object will have no mutable state at all. Objects without mutable state are usually (not always, but usually) thread-safe without any additional locking. Of course, if there's additional requirements that do imply mutable state, the answer would be different.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

How are you reporting the information? If it's to a console or any other resource that's independent of thread, there's your shared "state". Sort of. Some mechanisms for writing to a console will buffer lines, so you may not have problems, but over multiple lines you'll have to make sure that two don't write to it at the same time. For example, if I were to print:

Thread: A Method: doA Running Time: 4.6s

Then I'd want to make sure another thread doesn't start half-way through. Otherwise you may end up with something like this:

Thread: A Thread: B Method: doB Running Time: 4.6s Method: doA Running Time: 3.2s

Not so helpful.

Improve this answer

3 Comments

PrintStream is thread-safe, so if you do the printing with one call to System.out.println, then it is guaranteed that it won't interleave with what other threads may print.
Or then you can rely on the implementation detail of PrintStream that it synchronizes on itself (at least in Java 1.6.0_24), so by synchronizing on it you could do multiple calls to the print methods without interleaving with other threads.
@Esko: I'm wary of relying on an implementation detail like that. I think you're better off introducing your own lock. At least in my work, HotSpot isn't the only version of the JVM I have to support, and I imagine others are in the same boat. This probably isn't a problem for a homework question such as this one, but it's worth encouraging people to follow decent guidelines even in these cases.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.