We know that there there is one more reference (hard link) to the inode of the file readme.txt

The size of the java binary (’java’) is 46 bytes.

/etc/alternatives/java cannot have the same inode number as /usr/bin/java

bugs.txt is not the only filename pointing to its inode.

The file named /usr/bin/java can be either a hard link or a symbolic link.

There is exactly one sub-directory within the directory code.

The start() method must be overridden and explicitly called.

We can create a thread in Java by implementing the Thread interface.

There is only one way in which we can create threads in Java.

The run() method must be overridden and explicitly called.

Creating a thread by extending the Thread class is limited in that our ‘task’ class must be a descendant of Thread (i.e. can not extend another class).

OSs have always supported multiple threads.

In an OS that maps each user-level thread to a kernel-level thread, if one thread of a process blocks for I/O then the entire process will block waiting for that I/O to complete.

OSs that run on uniprocessors can not support kernel level threads.

User-level threads can be implemented in an OS that does not support threads.

With user-level threads in one-to-many mapping, the OS scheduler does not have total control over scheduling decisions for threads within a process.

Threads within the same process share the same global variables.

Threads within a process share the same stack pointer.

For a multi-threaded process, an OS will provide a separate address space for each of its threads.

The heap is shared amongst threads of the same process.

There are no benefits to writing multi-threaded programs for uniprocessor systems since only one thread at any point in time can be executing.

In multicore systems, threads of the same process are guaranteed to be scheduled on separate cores.

In the dining philosophers problem, the problems of starvation and deadlock are basically the same; in both cases philosophers go hungry.

If all philosophers pick up their right fork first, there can be no deadlock.

In the dining philosophers problem, the philosophers are threads/processes.

The dining philosophers problem is intended to represent the problem of sharing resources among multiple threads/processes.

In the dining philosophers problem, deadlock happens when eating is taking place overall, but one of the philosophers who wishes to eat is prevented from doing so.

To prevent deadlock in the dining philosophers problem, each philosopher should make a random choice about whether to pick up the left or right fork first.

A call to notify() or notifyAll() is not guaranteed to allow at least one thread waiting on a conditional variable to resume execution.

The Java Memory Model guarantees that if multiple threads are waiting in an object’s wait set, the thread that has been waiting the longest will get to run first.

In Java, a thread that is in the entry set for some critical region is not guaranteed that it will eventually run until completion.

A conditional variable can be used to enforce mutual exclusion.

In Java, if the entry set for an object is empty, then the wait set for the same object must also be empty.

A thread can be waiting on two conditional variables simultaneously.

The memory model guarantees that a call to the start() method on a thread happens before any actions in that thread.

The memory model does not guarantee that if two threads update the same object using a synchronized method, then both threads would see the changes occurring in the same order. 

The memory model guarantees that any changes made to a variable in one thread are immediately noticed in all other threads.

The memory model always guarantees that if two threads update the same variable then both threads would see the change in the same order.

In multi-core systems, changes of variable values in the local cache of a core are not immediately visible by threads running on other cores.

If the Java memory model made more guarantees than it does, multi-threaded programs would run faster but it would be more time-consuming for programmers to code them.

Deadlock can be avoided by using other methods for achieving mutual exclusion instead of locks.

Deadlock can occur when two threads try to acquire the same locks in different order.

Deadlock can be prevented by ensuring that there is a unique order in which locks (or other resources held like locks) are taken.

When a thread returns from conditional suspension (e.g. after a call to wait()), it can safely assume that the condition it was waiting for is now true.

Locks prevent the OS scheduler from performing a context switch during a critical region.

A thread can acquire more than one lock simultaneously.

A zombie process can be created if an appropriate wait function is not included in the code for case 2. 

All zombie processes are orphan processes.

We can kill a zombie process from a Unix/Linux terminal by using the kill command with the zombie process id.

The process with pid=1 ('init' process) periodically issues the wait system call to collect the exit status of its children processes.

Zombie processes are troublesome because they can consume a lot of memory.

A zombie process can be created if an appropriate wait function is not included in the code for case 1.