Multithreading questions

[Pooja Oza]

Can some one help me understand the output of the following programs ..... The examples are from SCJP 6 by K&B book, in the self test of multithreading chapter...

 

15. Given:
3. class Dudes {
4. static long flag = 0;
5. // insert code here
6. if(flag == 0) flag = id;
7. for(int x = 1; x < 3; x++) {
8. if(flag == id) System.out.print("yo ");
9. else System.out.print("dude ");
10. }
11. }
12. }
13. public class DudesChat implements Runnable {
14. static Dudes d;
15. public static void main(String[] args) {
16. new DudesChat().go();
17. }
18. void go() {
19. d = new Dudes();
20. new Thread(new DudesChat()).start();
21. new Thread(new DudesChat()).start();
22. }
23. public void run() {
24. d.chat(Thread.currentThread().getId());
25. }
26. }
And given these two fragments:
I. synchronized void chat(long id) {
II. void chat(long id) {
When fragment I or fragment II is inserted at line 5, which are true? (Choose all that apply.)
A. An exception is thrown at runtime
B. With fragment I, compilation fails
C. With fragment II, compilation fails
D. With fragment I, the output could be yo dude dude yo
E. With fragment I, the output could be dude dude yo yo
F. With fragment II, the output could be yo dude dude yo
Answer:
 3 F is correct. With fragment I, the chat method is synchronized, so the two threads can't
swap back and forth. With either fragment, the first output must be yo.
 A, B, C, D, and E are incorrect based on the above. (Objective 4.3)

   
16. Given:
3. class Chicks {
4. synchronized void yack(long id) {
5. for(int x = 1; x < 3; x++) {
6. System.out.print(id + " ");
7. Thread.yield();
8. }
9. }
10. }
11. public class ChicksYack implements Runnable {
12. Chicks c;
13. public static void main(String[] args) {
14. new ChicksYack().go();
15. }
16. void go() {
17. c = new Chicks();
18. new Thread(new ChicksYack()).start();
19. new Thread(new ChicksYack()).start();
20. }
21. public void run() {
22. c.yack(Thread.currentThread().getId());
23. }
24. }
Which are true? (Choose all that apply.)
A. Compilation fails
B. The output could be 4 4 2 3
C. The output could be 4 4 2 2
D. The output could be 4 4 4 2
E. The output could be 2 2 4 4
F. An exception is thrown at runtime
Answer:
® 3 F is correct. When run() is invoked, it is with a new instance of ChicksYack and c has
not been assigned to an object. If c were static, then because yack is synchronized, answers
C and E would have been correct.
®˚ A, B, C, D, and E are incorrect based on the above. (Objective 4.3)

 

   
17. Given:
3. public class Chess implements Runnable {
4. public void run() {
5. move(Thread.currentThread().getId());
6. }
7. // insert code here
8. System.out.print(id + " ");
9. System.out.print(id + " ");
10. }
11. public static void main(String[] args) {
12. Chess ch = new Chess();
13. new Thread(ch).start();
14. new Thread(new Chess()).start();
15. }
16. }

And given these two fragments:
I. synchronized void move(long id) {
II. void move(long id) {
When either fragment I or fragment II is inserted at line 7, which are true? (Choose all that apply.)
A. Compilation fails
B. With fragment I, an exception is thrown
C. With fragment I, the output could be 4 2 4 2
D. With fragment I, the output could be 4 4 2 3
E. With fragment II, the output could be 2 4 2 4
Answer:
 3 C and E are correct. E should be obvious. C is correct because even though move() is
synchronized, in this case two different objects are invoking it.
 A, B, and D are incorrect based on the above. (Objective 4.3)

 

I m stuck in these few questions, if some one can help me it would be great...... Thanks

[Alfred Swensen]

Pooja Oza wrote:Can some one help me understand the output of the following programs ..... The examples are from SCJP 6 by K&B book, in the self test of multithreading chapter...

The Dudes question:

You run the thread with two newly created DudesChat instances. But that's not the point as the run() method only refers to the d variable which is exactly the same for both threads.
As it is the same, the synchronized keyword in fragment I works as expected, the output will always be "yo yo dude dude" which appears in none of the possible answers.
With fragment two you have a typical unsynchronized case i.e. both methods could theoretically be entered and run at the same time. So F is at least possible.

The exam authors claim that "yo" must always be the first output although I think that it is theoretically possible that one thread sets the flag variable and immediately after that the other thread starts and completes the chat method so that "dude dude" is printed first. Any ideas if this might be possible?


The Chicks question:

You create two threads, each with a *new* instance of the ChicksYack In this new instance the c variable (which is not static as the d in the above example!) was never initialised so if the thread scheduler calls the run() method of these new instances you get a NullPointerException when it tries to call the method .yack(...) on the uninitialized variable c.

The Chess question:

Here, too, you start two threads with different instances of a class. So whether or not you put synchronized before a method is irrelevant as they both only lock their instance.
The output is thus random for both examples. As there are only two threads there can never the case where three different id values are printed so option D is invalid.


Hope that helps!

[Pooja Oza]

Hi Alfred,

Thanks for your help.

But i still do not get that how come the output of the Chess and the Chicks problems have the output options like : 4 4 2 2 or whatever..... where and how do these numbers come from? Can you please clear that if possible.

[Ken Truitt]

wow those are hard.

In the Chicks question, note that the go() method which spawns the threads happens to initialize c just before it
starts the threads based on two NEW instances of the ChicksYack class. This is there only to confuse people. You
would have to manually initialize the c field in the instances of the ChicksYack class used by the threads for the
program to work properly (or just make c static, as they say in the answer).

I think the thread id's are just examples that they made up. The only thing you would want to be sure about is
that there can only be 2 id's, so answers with 4's, 2's AND a 3 are going to be wrong. Actually it's pretty confusing
with respect to the first question because I'm not certain that one of the spawned threads couldn't have an id of
zero.

[Bob Ruth]

Looking at the last one first..... Two threads are instantiated and each one is passed a SEPARATE DISTINCT Chess object. So, when each thread starts up it refers to a different instance of Chess object. What THAT part means is that the synchronization applied to the method in I is useless. The method in each object synchronizes on its OWN "this" and they are different so there will be no coordination at all.
The other part on the number sequence comes from this: Each thread that is started has an ID and that ID will stay the same for it's entire life cycle. So any answer with three values is wrong because there are only two runnable objects being run, so there will only ever be two IDs show up. The one that has 4, 2, AND three, is obviously wrong. Since the run method defines what each "runnable" will do, the ID will only be printed twice for each instance of the runnable. So any answer that shows a given ID 3 times is wrong.
The only issue that remains is the order. Since they are unsynchronized with respect to each other the IDs can really come out in any pattern/permutation.
(ie 4422, 2244, 2442, 4224, 2424, 4242)

[Pooja Oza]

Thanks Ken and Bob, i really understood those programs now.......
thanks a lot

[neha chaukar]

In the dudes example also, two threads are started with different instances of class i.e.
new Thread(new DudesChat()).start();
new Thread(new DudesChat()).start();

so here also synchronised should not play any role as in chess example.

Help me understand this.

[Heena Agarwal]

neha chaukar wrote:In the dudes example also, two threads are started with different instances of class i.e.
new Thread(new DudesChat()).start();
new Thread(new DudesChat()).start();

so here also synchronised should not play any role as in chess example.

Help me understand this.

But both these different instances have the same Dudes. Remember that d is a static reference pointing to a Dudes. Hence that Dudes is shared by all the objects of DudesChat.