Race conditions are not a problem if we only have a computer with a single CPU.

Allowing two or more threads to access a critical region at the same time is desirable.

A thread can only block other threads from a critical region once that thread is inside the critical region.

A race condition is when two or more threads are racing against each other and it is hard to predict the winner.

In concurrent programming, a critical region is a part of the program where time-critical (or safety-critical) operations take place.

If only one thread at a time can access a shared resource, we have enforced mutual exclusion.

Line 5 is executed by the parent process and its child processes.

Assuming that the scheduler runs the parent process to completion first, the output of the program will be:

The value of x is -1

The value of x is 0

At line 3 the sleep function is called. This line is executed by both the parent and child processes.

Assuming that the scheduler runs the parent process to completion first, the output of the program will be:

The value of x is 0

The fork call executes a new program.

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.

In Java, a thread is an instance of the Thread class.

A new Java thread is executed by implementing a start method and then calling the run method of a Thread instance.

A thread can't be restarted again after its run method has completed.

One way to start a thread is to call its run method.

A new thread instance can be created using a constructor that takes a Runnable parameter.

The access permissions for this file allow everyone to read it.

We can be certain that there is one more file, other than hello.php, that is linked to the same inode number 21109162.

We can be certain that the access permissions to the file were changed on 2026-01-24 00:06:41 (ctime). 

The file size is 88 bytes and we need 8 blocks for it, so each block is 11 bytes. 

A symbolic (soft) link to hello.php will have a size of 88 bytes.

We can be certain that the file’s content was last modified on 2026-01-24 00:06:41 (mtime) (assume no hacking attempt on the file).

The method ‘read’ does not need to be synchronized, only the write method needs to be made synchronized.

The ‘sleep()’ method is an alternative to ‘wait()’ as either can be used to pause a thread for a defined period of time.

In the read method, we can implement the desired functionality by adding the following control:

if (contents == null) {   

    wait() ;

}

In order to implement the desired functionality,  the write method  should include (at least) the following code:

while (contents != null) {

      wait() ;

}

contents = entry ;

notifyAll() ;

Since the ‘Mailbox’ class must contain (at least) a synchronized  write method to make it thread safe, Mailbox should extend the Thread class (or implement the ‘Runnable’ interface).

The ‘wait’ method can only be called from inside a synchronized method/block.

If fork succeeds there are 3 different processes involved: the original process that calls fork, the parent process and the child process (the new process).

The fork system call is used rarely. In normal use of Linux when using the shell fork is not used.

The point in the program marked ‘case 2’ is reached in the child process; the value of the ‘pid’ variable is zero.

The fork call immediately causes all the memory pages owned by the process making the call to be copied for the new process.

Fork can fail if there are no more process ids available for allocation by the operating system.

Case 2 is not really needed as it only applies when the process id is zero and no (user) process has an id of zero. This case is only included for robustness.

Using multi-level feedback queues eliminates process starvation.

Multi-level feedback queues implement a dynamic priority system.

Round Robin is a starvation-free scheduling algorithm.

Using static priorities for scheduling, and ensuring that always a higher priority process is served before any lower priority processes, is always a fair scheduling method and does not entail the danger of process starvation.

In preemptive scheduling, it makes sense to make the quantum time (q) very short (e.g. 1 msec). In this way the CPU will more rapidly swap between processes and the illusion of "many things happening at the same time" will be even stronger.

In non-preemptive scheduling (such as FCFS) it is possible that a process may occupy the CPU until it finishes completing, no matter how long this may take.

Processes whose burst pattern is more like that in the left hand side of the distribution shown in the figure, would correspond mostly to batch processes.

The figure tells us that the majority of processes have relatively short CPU bursts.

Processes whose burst pattern is more like that in the right hand side of the distribution shown in the figure, would correspond mostly to interactive processes.

For batch processes, throughput matters most, while for interactive processes it is response time that matters the most. 

The distribution shown in the graph has no implications for process scheduling.