Reference no: EM13924134

1. For the following program, explain the interesting lines of code related to threads and explain the output of the application (do not show the output, just explain it).

You may experiment with the program using the attached source code by copying and pasting it into your IDE.

public class TaskThreadDemo{
public static void main (String args []) {
String [] sa = {"a", "X", "+", "."};
for (String s: sa) {
Runnable ps = new PrintChar (s, 200);
Thread ts = new Thread (ps, s);
ts.start ();
} // end for each character
} // end main
} // end class TaskThreadDemo
11

class PrintChar implements Runnable {
String ch;
int times;
15
public PrintChar (String c, int n) {
ch = c;
times = n;
} // end constructor
20
public void run () {
for (int i = 0; i < times; i++) {
System.out.print (ch);
} // end for loop
} // end method run
} // end class PrintChar

What is changed if the method called on line 7, start(), is replaced with run()? Explain (of course).

What is changed if the method Thread.yield() is added between lines 23 and 24? Explain.

Write a small code example using a ReentrantLock (no more than 10 lines).

How do you guarantee that the lock is released when your code finishes?

The dining philosophers problem was invented by E. W. Dijkstra, a concurrency pioneer, to clarify the notions of deadlock and starvation freedom.

Imagine five philosophers who spend their lives just thinking and feasting.

They sit around a circular table with five chairs.

The table has a big plate of rice. However, there are only five chopsticks (in the original formulation forks) available, as shown in the figure below.

Each philosopher thinks. When he gets hungry, he sits down and picks up the two chopsticks/forks that are closest to him.

If a philosopher can pick up both chopsticks, he can eat for a random amount of time.

After a philosopher finishes eating, he puts down the chopsticks and again starts to think.

What is wrong with everybody doing the following - other than that the philosophers never get up from the table?

think for a while

get left chopstick

get right chopstick

eat for a while

return left chopstick

return right chopstick 7. return to 1

How can the above be fixed to avoid deadlocks?

Write a simple thread example that contains a loop that sleeps for 30 seconds.

The loop should execute until a "shutdown" flag is set to true on the runnable object executing in the thread.

From your code in the previous question, when the shutdown flag is set to true, will the thread exit immediately?

What if it is in the sleep call?

How can the thread be woken up immediately by another thread?

Describe how a semaphore can be used to act like a Lock.

What feature does a semaphore offer over a Lock?

How can you ensure that the thread that asked for the permit first will get the permit first when using a semaphore?