Concurrency

Question 1

What are the conceptual from of tasks?

Answer 1

A process is started when the Java program is first ran, causing the OS to allocate it resources. It starts with one executing three

One or more threads exist within a process and can execute to complete a task.

A task is a set of program instructions as defined by the written code.

Question 2

What are the measures of success for a concurrent application?

Answer 2

Efficiency - how little computing resources can be used

Responsiveness - how soon can events be responded to

Task separation - allows for interleaving i.e. stops one task blocking the others

Question 3

What is the difference between threads and processes?

Answer 3

Both get their own method call stack and program counter (keep track of which line of code). However, threads share the memory heap wiht threads from the same process.

Question 4

How can threads be paused to allow execution of other threads?

Answer 4

Either voluntarily in “cooperative scheduling” in which they yield when able to.

Otherwise the SO interrupts them - “preemptive time slicing”

Question 5

How do Java threads relate to OS supported threads?

Answer 5

OS-supported threads run each thread on the same CPU / core. Threads from the same process may run on different CPUs.

Java threads run as OS-supported threads, but the JVM typically switches them between different OS-supported threads over time.

Question 6

What is the basic lifecycle of a thread?

Answer 6

They start as “new” when created by become “runnable”.

When runnable, the OS manages the transition between “ready” and “running”

Other states it may be in include waiting, timed waiting (wait but with timeout), blocked (waiting to acquire a lock etc.) and terminated (it is done)

Question 7

How is the transition from ready to running managed?

Answer 7

This is all hidden from the JVM - both are simply encompassed by Runnable.

The OS determines when to “dispatch” the thread and hence move it on to the processor. This is called “thread scheduling”

Question 8

How are threads created?

Answer 8

By defining a new class that extends the Thread class. Specifically the run() method must be overridden.

An instance of that class is then created and then executing by calling .start() on it.

Question 9

What parameter must thread constructors have?

Answer 9

The name of the thread. Optionally it can also have a custom runnable.

Question 10

How can threads be created using the Runnable interface?

Answer 10

Define a new class that implements the Runnable interface.

Implement a run() with the task to be executed.

Instantiate a new Thread with the custom runnable as the constructor, as well as the thread name. Execute this thread.

Question 11

How can the current thread be accessed?

Answer 11

With Thread.currentThread().

For example, the name of the current thread can be retrieved with Thread.currentThread().getName()

Question 12

When is it best to implement Runnable versus extend Thread?

Answer 12

When it makes sense to extend from a different class (multiple inheritance is not allowed)

The Runnable instance can be used over multiple threads, helping reduce memory consumption.

Question 13

What are the two basic types of thread?

Answer 13

Daemon threads provide support to non-daemon threads. These do not help keep the application alive.

Non-daemon threads are the key threads of the application such as the main thread (for console applications) or the event dispatch thread (GUI).

If all non-daemon threads have terminated then the daemon threads, and hence entire application, is terminated.

Question 14

When a thread is created, what type is it by default?

Answer 14

A user thread (non-daemon)

Question 15

What are daemon and non-daemon threads also called?

Answer 15

Daemon - background, service

Non-daemon - user threads

Question 16

How can threads be made daemon or not?

Answer 16

With myThread.setDaemon(true/false). This must be done BEFORE the thread is started.

To determine if a thread is daemon or not, use .isDaemon

Question 17

What is an alternative way of executing Runnable objects?

Answer 17

This object can be passed to an ExecutorService which manages a pool of reusable threads behind the scenes.

Question 18

How are executor services used?

Answer 18

They are created using the Executors.newCachedThreadPool() static method.

Runnable can be executed using service.execute(runnable)

Question 19

How can an executor with a specific number of threads be created?

Answer 19

Use Executors.newFixedThreadPool(int nThreads)

Question 20

What methods do executors provide to manage termination?

Answer 20

shutdown() - initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks are

shutdownNow() - attempts to stop all executing tasks

awaitTermination() - blocks the invoking thread until all tasks have been completed / timed out

Question 21

What are race conditions?

Answer 21

When multiple threads are accessing mutable shared data at the same time

Question 22

What are atomic operations?

Answer 22

Those that operate on share memory as a single step from the perspective of other threads.

Therefore, intermediate values cannot be messed with

Question 23

What are the methods of AtmoicInteger?

Answer 23

get()

getAndIncrement()

getAndAdd(int delta)

Question 24

How can methods be made thread safe?

Answer 24

With the “synchronised” keyword i.e. public synchronised void doSomething() { }

This allows only one thread at a time to execute the method. Any other thread will be blocked.

Question 25

How does the synchronised keyword work behind the scenes?

Answer 25

Every object in Java has Monitor. This ensures that every MonitorLock is held by a maximum of one thread at a time

Question 26

How are synchronised blocks used?

Answer 26

They are used inline i.e. synchronised(object) { … }.

Note that they must declare which object is being synchronised. For example, they can synchronise on single instance variables

Question 27

What is a producer/consumer relationship?

Answer 27

A common pattern in which one thread (the producer) generates data and stores it in a shared object. They consumer thread reads the data from the other end of the shared object.

The data structure is called a buffer

Question 28

How do waiting threads work?

Answer 28

Threads can be placed into a waiting state by calling the .wait() method of the object class. It will continue waiting until it is notified buy another thread that it can continue.

Threads can notify other threads by calling notify() or notifyAll()

Question 29

How does Java provide thread-safe collections?

Answer 29

With BlockingQueue() and ArrayBlockingQueue(int capacity)

Alos synchronisedList

Question 30

What does BlockingQueue do?

Answer 30

It is a queue that supports operations that wait for the queue to be non-empty when retrieving and wait for space when storing an element.

Question 31

What does ArrayBlockingQueue do?

Answer 31

It is a bounded blocking queue backed by an array. Its methods include:

Add() - insert or throw error if no space
Put() - insert but wait if no space
Remove() - return head or throw error if empty
Poll() - return head or wait until timeout

Question 32

What is Deadlock?

Answer 32

When thread A is waiting for thread B but B is waiting for A

Question 33

What is starvation?

Answer 33

Threads with low priority might never get ran if higher priority threads keep getting ran instead

Question 34

In the context of GUI, what are windows?

Answer 34

Top-level containers i.e. JFrame

Question 35

In the context of GUI, what are components?

Answer 35

GUI widgets that can be placed inside containers

Question 36

In the context of GUI, what are containers?

Answer 36

Logical grouping of components

Notably they are responsible for laying out these components using LayoutManagers