Java - Writing to shared array from multiple threads

Question

There is this problem called the "1717171717". It sounds really simple but I can't get my head around the algorithm to do it. Here is the problem brief:

Write a concurrent Java program which declares an array of 10 integers. Create two threads. One which writes the value 1 to every element in the array. The second thread writes the value 7 to every element of the array. When both threads have terminated, print out the array. The result when both threads terminate has to be (1,7,1,7,1,7,1,7,...) or (7,1,7,1,7,1,7,...). You will need to use a synchronized method or a synchronized statement to achieve this. Note, each thread must write to every element of the array.

Furthermore, each thread should write to each element only once, I'm told.

Here is what I have. I need an algorithm that will meet this within the run() method. Any help would be appreciated.

import java.util.ArrayList;

class SharedData
{   
    public static void main(String[] args) throws InterruptedException
    {
        ArrayList<Integer> data = new ArrayList<>(10);
        for (int i = 0; i < 10; i++)
            data.add(0);
        Writer.array = data;

        Thread one = new Thread (new Writer(1), "Ones");
        Thread seven = new Thread (new Writer(7), "Sevens");
        one.start();
        seven.start();
        one.join(); seven.join();
        data.forEach(System.out::println);
    }
}

class Writer implements Runnable
{
    public static ArrayList<Integer> array = new ArrayList<>();
    final int value;
    Writer (int val) {
        this.value = val;
    }

    public void run()
    {
        for (int i = 0; i < array.size(); i++) {
            synchronized (array) {
                try
                {
                    //Algorithm?
                    array.set(i, value);

                    array.notifyAll();
                    if (i < array.size()-1)
                        array.wait();
                }
                catch (InterruptedException ie) {
                    System.err.println(ie.getMessage());
                }
            }
        }
        System.out.println(Thread.currentThread().getName()+" terminated.");
    }
}

May I ask why my question got so many downvotes? – Sina Madani Feb 02 '16 at 16:18 — Sina Madani, Feb 02 '16 at 16:18
You should use an array, not an arraylist. – assylias Feb 02 '16 at 16:20 — assylias, Feb 02 '16 at 16:20

score 0 · Accepted Answer · answered Feb 02 '16 at 16:16

0

Try:

t1 writes a[0] = 7
t2 writes a[0] = 1, a[1] = 1
t1 writes a[1] = 7, a[2] = 7
t2 writes a[2] = 1, a[3] = 1
...

answered Feb 02 '16 at 16:16

Jean Logeart

52,687
11
83
118

This is the only answer that meets the requirements. Although the trick is actually implementing it! – Sina Madani Feb 02 '16 at 20:21

António Ribeiro · Answer 2 · 2016-02-02T16:28:06.603

0

You could do two runs for each thread T1 and T7:

On the first run, you allow only the thread T1 to write on even indexes of the array and the T7 on odd indexes of the array;
On the second run, you do the opposite: T1 writes on odd indexes and T7 on even indexes.

edited Feb 02 '16 at 16:28

answered Feb 02 '16 at 16:18

António Ribeiro

4,129
5
32
49

@assylias, you're right... no need for the happens-before here. – António Ribeiro Feb 02 '16 at 16:27
Exactly, it will write at the end of the second run... On the first T1 goes through the evens and T7 over the odds; on the second they'll switch and T1 will go through the odds and T7 through the evens. That way both of them write to every element in the array. – António Ribeiro Feb 02 '16 at 16:32
@AndyTurner perhaps not the most efficient solution... :/ – António Ribeiro Feb 02 '16 at 16:34
@aribeiro using 2 threads to fill a 10-element array isn't an efficient solution, period. – Andy Turner Feb 02 '16 at 16:35
@AndyTurner true story! – António Ribeiro Feb 02 '16 at 16:44

Java - Writing to shared array from multiple threads

2 Answers2