Question

At work training, I’m writing a Java (in which I have 0 experience) program that should meet the following criteria:

Write a program that replicates distributed computing application

Create central ‘scheduler’ object which contains a list of M random numbers

Create N processor threads that retrieve a number from the scheduler then loop that many times before requesting another number

If no numbers are available from the scheduler, wait to request another number.

If no more numbers are left, all the threads should end.

So far, I created an object with an array of random numbers, but I really don’t know how to proceed with multithreading. Could someone please guide me through it? This is what I have so far, along with comments indicating pseudo code.

public class ThreadDemo extends Thread
{
    //create new array of arbitrary size 5
    static int SIZE = 5;
    static int[] myIntArray = new int[SIZE];
    
    
    public ThreadDemo()
    {
        start();
    }
    
    class RunnableThread implements Runnable {

        Thread runner;
        public RunnableThread() {
        }
        public RunnableThread(String threadName) {
            runner = new Thread(this, threadName); // (1) Create a new thread.
            System.out.println(runner.getName());
            runner.start(); // (2) Start the thread.
        }
        public void run() {
            //Display info about this particular thread
            System.out.println(Thread.currentThread());
        }
    }

    
    public static void main(String[] args)
    {
        for(int i=0; i<SIZE; i++)
        {
            myIntArray[i] = (int)(Math.random() * 10);
        }
        
        ThreadDemo scheduler = new ThreadDemo();
        
        //create M processor threads that retrieve number from scheduler
            //for(int i=0; i<SIZE; i++)
                //
        
        //if no threads available
            //make the scheduler thread wait() ??
        
        //if empty
            //stop() the scheduler thread ??
        
    }

    }

Could anyone steer me in the right direction?

Thank you!

Answer 1

As a first pointer: don’t start threads in a constructor and don’t use the Runnable object to start a thread using itself. It’s very confusing to whoever reads the code.

Here’s my take on this problem (hope I didn’t get carried away):

class Scheduler {
    private int[] numbers;
    private AtomicInteger current = new AtomicInteger();

    public Scheduler(int count) {
        Random rand = new Random();
        numbers = new int[count];
        for(int i = 0; i < count; i++) {
            numbers[i] = rand.nextInt();
            if(numbers[i] < 0) numbers[i] *= -1;
        }   
    }

    public int getNextNumber() {
        int local = current.incrementAndGet();
        if(local >= numbers.length) {
            return -1;
        }
        return numbers[local];
    }
}

First, we define the Scheduler class that holds an array of random (positive) integers and returns a number from the array on-demand, based on an atomically incrementing counter.

class Task implements Runnable {

    private Scheduler scheduler;  

    public Task(Scheduler scheduler) {
        this.scheduler = scheduler;     
    }

    public void run() {
        while(true) {           
            int limit = scheduler.getNextNumber(); // get next number
            if(limit == -1) return; // no more numbers
            System.out.println(limit);
            for(int i = 0; i < limit; i++) {
                // spin
            }
        }
    }       
}

The Task class holds the code that each thread executes. Each thread loops indefinitely requesting numbers from the Scheduler, until the array is exhausted.

public class Test {

    public static void main(String[] args) throws InterruptedException {

        Scheduler s = new Scheduler(100);
        ExecutorService exec = Executors.newFixedThreadPool(4);
        for(int i = 0; i < 4; i++) {
            exec.submit(new Task(s));
        }

        exec.shutdown();
        exec.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);       
    }
}

In the main class we set up a thread pool and execute 4 threads to do the aforementioned tasks.