Thread Safe primitive and an Object Array

I was working on a proof of concept for a product, when I ran in to this issue, so I wrote a sample program. To cut to the chase, how do I make this array thread safe ?. Honestly, from the program below, any thread can modify the contents of the array. I was about to explore the possibility of using AtomicIntegerArray / AtomicReferenceArray.

Please advice!.

import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class HowToMakeAnArrayThreadSafe {

public static void main(String[] args) {

final ThreadFoo f = new ThreadFoo();

Thread t = new Thread(new Runnable() {

public void run() {
                f.operateOnThisArray();
            }
        });
        Thread t1 = new Thread(new Runnable() {

public void run() {
                f.noNeedOfSynchronize();
            }
        });

t1.start();
        t.start();
        try {
            Thread.sleep(TimeUnit.SECONDS.toSeconds(3000));
        } catch (InterruptedException ex) {
            Logger.getLogger(HowToMakeAnArrayThreadSafe.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        try {
            t1.join();
            t.join();

} catch (InterruptedException ex) {
            Logger.getLogger(HowToMakeAnArrayThreadSafe.class.getName()).log(Level.SEVERE, null, ex);
        }

f.printFoo();
    }
}

class ThreadFoo {

private final int[] originalArray = new int[5];

ThreadFoo() {
        for (int i = 0; i < originalArray.length; i++) {
            originalArray[i] = i;
        }
    }

public void operateOnThisArray() {

synchronized (originalArray) {

System.out.println(" Modifying : " + Thread.currentThread().getName());

for (int i = 0; i < originalArray.length; i++) {
                originalArray[i] = i;
            }
            try {
                Thread.sleep(TimeUnit.SECONDS.toSeconds(8000));
            } catch (InterruptedException ex) {
                Logger.getLogger(ThreadFoo.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

public void noNeedOfSynchronize() {

int def = (int) Thread.currentThread().getId() % 3;

originalArray[def] = 48;
        originalArray[def + 1] = 89;

}

public void printFoo() {
        for (int i = 0; i < originalArray.length; i++) {
            System.out.print(originalArray[i] + " ");
        }
    }
}

Best Regards!!..

_SM

First, you need to define what is thread safe. Is it that when an element is changed, partial writes should not be seen? It it when looping through the array, it can't be changed until the loop is complete? etc. etc.

Henry

Steven Rodeo wrote:
Honestly, from the program below, any thread can modify the contents of the array. I was about to explore the possibility of using AtomicIntegerArray / AtomicReferenceArray.

To make something thread safe, you can use synchronization, or you can use the classes you mentioned -- but keep in mind that the atomic classes is for optimistic locking, which is much harder to implement than synchronization. It is not a magic bullet -- that is easier to use than synchronization.

Henry

Henry,

what I meant was,

int [] qu = new int[20];

even if I do a synchronized(qu) {

}

this won't stop other threads from changing the contents of the array ?. The example I gave you, shows a thread (sleeping for 8 seconds) holding the lock. And another thread modifying the contents of the Array.

So I wanted to know, how I can make it thread safe ( the whole Array ), not just the reference

_SM

Steven Rodeo wrote:
this won't stop other threads from changing the contents of the array ?. The example I gave you, shows a thread (sleeping for 8 seconds) holding the lock. And another thread modifying the contents of the Array.

So I wanted to know, how I can make it thread safe ( the whole Array ), not just the reference

One requirement of thread safety is cooperation. All the threads must behave together to achieve thread safety. This means that all the threads must agree on how they will behave with the data -- or better yet, the data should be held private, with all public methods that access the data to behave in a cooperative manner.

If you need to operate on the whole array -- and for an operation that is longer than a single read or write -- you can't just give away access to data and expect it to be thread safe.

Henry

Steven Rodeo wrote:
I was about to explore the possibility of using AtomicIntegerArray / AtomicReferenceArray.

AtomicIntegerArray will not automagically make your array thread safe.
You must still synchronize each access to array elements in your code, but using other technique,
for example like this: