Threads and concurrency / Safety SPL – PS6 Threads and concurrency / Safety

Overview Threads Threading in Java Concurrency and safety Callback functions The singleton

Threads Up until now, all the programs we’ve seen were sequential. Modern operating systems allow the execution of several processes at the same time. If the tasks we need to perform are related, we can put them in the same process, this is achieved using Threads. Threads running in the same process share resources (e.g memory, code and files)

Using threads In order to run several tasks in parallel, two steps should be taken: Define the tasks Create threads and assign each task to a thread Defining a thread is done in Java by implementing the runnable interface, which has a single method void run().

Using threads (cont) Using Java’s Thread class. The constructor of the Thread class accepts a Runnable object. Calling start() first allocates resources for the thread, and then calls the run() function of the thread.

Java’s executor service An executor is a service that internally manages threads, and allows you to assign tasks for them. There are many types of executors, with different policies of managing their internal thread.

Concurrency and safety Safety problems arise when multiple threads access the same resource. A shared resource is every object which is visible to more than one thread. That includes, global objects, class members, but not local function variables.

The Counter class The output of the program is not deterministic. Why? Let’s look on the increment method: The second line of the code involves three basic operations: Read the value of count Increment that value by 1 Write the new value to count

Dangers of threads As we’ve seen, running things concurrently can be dangerous. Two tasks can interfere with one another, leading to unexpected results. Let’s observe two more cases in which a multi-threaded execution could cause problems.

Avoiding safety problems There are a few design approaches for avoiding safety problems. We will go over a few approaches in this practical session

Thread confinement If a resource is accessed only by one thread, no synchronization is needed. You can confine certain variables to just one thread.

Immutability An immutable object’s state cannot be changed after construction. It can be safely used by many threads as a read only object. For example, the String, and Integer classes in Java are immutable. The final keyword in Java is similar to the const keyword in C/C++. Final fields can’t be modified, but objects they refer to can be modified if they are mutable.

Immutability (cont) A class will be immutable if the following are true: All of it’s fields are final The class is declared final The this reference is not allowed to escape during construction Any fields that contain references to immutable objects: Are private Are never returned or exposed to the caller Are the only reference to the object they refer to Do not change the state of the referenced object after construction.

Immutability example

Callback functions A callback function is a function which is passed to another function as a parameter. We can simulate this behavior in Java using interfaces. Anonymous classes and lambdas can capture variables, with some restrictions: An anonymous class has access to members of it’s enclosing class. An anonymous class cannot access variables in it’s enclosing scope that are not declared as final or effectively final. A declaration of a variable in an anonymous class shadows any other declaration in it’s enclosing scope.

The singleton In some cases, you’ll want to have exactly one instance of a class in your program. Those types of objects are accessed throughout the program, and therefore require a global point of access.

The singleton (cont) This naïve implementation of the singleton works well in a single threaded environment, but not in a multi-threaded one.