Concurrency

Question 1

What is concurrency?

Answer 1

The ability to perform multiple processes simultaneously, including the potential interaction between them

Question 2

What part does the OS play in concurrency

Answer 2

It schedules processes

Question 3

Give 2 reasons why we use concurrency

Answer 3

Allows programs to interact with other systems/ users

Makes use of multi-core systems

Answer 4

Multiple cores sare processes that the OS needs to run

Each process that the OS needs to run has its own memory space

Question 5

Explain the structure of multi-threading

Answer 5

Begins by running main thread
Main thread consists of multiple child threads
When child thread starts running, main thread is free - it begins execution of the next child thread

Question 6

How does memory allocation work with threads

Answer 6

Memory space allocated to a single process
All threads involved in that process share this memory space
Threads have their own local variables

Question 7

What is a thread

Answer 7

Threads can be treated as lightweight processes. There are many threads within a single process.

Question 8

Explain the structure of threads when a program is run

Answer 8

Main thread begins to run immediately
Main thread consists of many child threads
Once the first child thread begins to run, the main thread is free so it starts up the next child thread

Question 9

How can we use sequential execution to reduce nondeterminism from multi-threaded execution

Answer 9

Map the multi-thread program to a sequential execution
Have all threads behave deterministically
Thus, entire program deterministic

Question 10

How can multi-threading cause nondeterminism (when different outputs are produced for the same input)

Answer 10

If two child threads are at the same level, we would want them to run concurrently
OS scheduling can cause nondeterministic behaviour due to environmental conditions (e.g. memory availability, interrupts etc.)
This affects the concurrency of the two threads

Question 11

Explain how the OS assists with the execution process of processes

Answer 11

The OS decides which cores execute which processes

Memory space is allocated per process that the OS needs to undertake

Question 12

What is liveness

Answer 12

Ensuring code performs correctly in time

An acceptable time depends on the application

Question 13

How do you synchronize a set of statements

Answer 13

Pass an object in as a parameter
All statements in the synchronized block will be synchronized

synchronized (this) {
    // everything in here is synchronized
}

Question 14

How do synchronized methods work

Answer 14

One synchronized method is executed from an object
All synchronized methods for the same object block suspend execution
Until the first thread is done with the object

Question 15

What are race conditions

Answer 15

When two threads try to access/change data at the same time

Question 16

Name two ways to stop a thread

Answer 16

Setting a flat => when the loop exits, thread will stop
Interrupting => thread stops with isInterrupted() called; if thread sleeping/waiting, InterruptedException is thrown and returns from run

Question 17

What is a disadvantage of extending from the Thread class when creating threads

Answer 17

You can only extend from one class - multiple inheritance not allowed
Waste of inheritance if we don’t make use of all the resources provided by the inheritance

Question 18

What do each of “new” keywords do in the following code

new Thread (new HelloRunnable()).start()

Answer 18

1) Creates a new instance of the thread

2) Creates an instance of a class (anonymous inner)

Question 19

Name two ways threads can be created in Java

Answer 19

Implementing Runnable

Extending Thread

Question 20

How do you synchronize a set of statements

Answer 20

Pass an object in as a parameter
All statements in the synchronized block will be synchronized

synchronized (this) {
    // everything in here is synchronized
}

Question 21

What are atomic actions? How do you declare them?

Answer 21

Actions that are self-contained; they cannot be stopped in the middle
They’re declare volatile
Reads and writes are atomic for most primitive variables