Paralleelprogrammeerimise keeled 2023/24 sügis

Simple threads

Study the following class:

// Subclass extends Thread class
public class PrintNameThread extends Thread {

    PrintNameThread(String name) {
        super(name);
    }

    // Override the run() method of the Thread class.
    // This method gets executed when start() method
    // is invoked.
    public void run() {
        System.out.println("run() method of the " + this.getName() + " thread is called" );
    }
}

Then consider this class:

public class ExtendThreadClassTest0 {

    public static void main(String args[]) {

        // Create object instance of a class that is subclass of Thread class
        System.out.println("Creating PrintNameThread object instance..");
        PrintNameThread pnt1 =
                new PrintNameThread("A");

        // Start the thread by invoking start() method
        System.out.println("Calling start() method of " + pnt1.getName() + " thread");
        pnt1.start();

    }
}

What output do you expect? Implement and run the program in your IDE. Is the output as expected?

Threads returning values

Write a program which starts two threads and passes a name as a String two each of them (two different names). You can either hardcode those names or ask the user for them. Each thread should return "Hello <name>" to the main thread. The main thread should print out those two messages once both threads have finished. How many classes do you need for this? If you want, put a sleep() into the thread to see the main thread waiting for the threads to finish.

Threads doing real work

We want to find the number in a range of positive numbers which has the maximum number of divisors. A divisor is a number which divides another number with remainder 0. For example, 9 has two divisors, namely 3 and 1, whereas 8 has three, namely 1,2, and 4 (if the 1 is included or not does not matter for the maximum). Using the int data type should be enough for this exercise.

As a first step, write a program which finds the divisors for a number.

Then extend this to find the maximum number of divisors for a range in a sequential fashion. Try this out for e.g. the range from 1 to 1000 and 1 to 100,000 and 1 to 10,000,000. Record how long it takes for 1 to 10,000,000.

Finally, implement a concurrent version. For this, write a thread which finds the maximum for a range. Then write a program which uses this thread to calculate the maximum for the range of 1 to 10,000,000. Try out what happens if you divide the range in different number of chunks. You can start with 2 and increase it. Do you get a speedup compared to the serial version?

Is there a need to use synchronized or volatile in this exercise?