java中数组的并发更新

Question

in java, I have a large array of strings.

I have one thread doing something like this:

for (int i=0;i<10000;i++) array[i] = getSomeValue();

I have another thread doing something like this:

for (int i=10000;i<20000;i++) array[i] = getSomeValue();

and another thread doing:

for (int i=20000;i<30000;i++) array[i] = getSomeValue();

and so on.

do I have to do something special to do this operation ?

will it work ?

I am trying to populate this large array faster by splitting the task into multiple threads but I wonder if this is the correct thing to do.

I am working with a 64 bit machine 16 cpus and all the fancy stuff.

Answer 1

Your code will work fine.

Different portions of an array are independent of eachother.

The spec says:

One implementation consideration for Java virtual machines is that every field and array element is considered distinct

Answer 2

This should work fine. However, if you want to be sure it's safe, you can populate different arrays in each thread and then System.arraycopy() them into one big array.

Answer 3

you can safely init the array with this code, however any code which needs to use the array afterwards needs to be correctly synchronized with the threads which are doing the initial updates. this can be as simple as "join"ing all the init threads before using the array.

Answer 4

With Java 8, this has become much easier:

Arrays.parallelSetAll(array, i -> getSomeValue());

This should also solve the problems of visibility mentioned in other answers and comments.

Answer 5

It should be fine unless getSomeValue() has side-effects that change mutable state that multiple threads access. If it doesn't have any state-changes, then you are set. You won't access the same bit of memory in any of the loops.

Whether or not it will actually be faster depends on your hardware setup and threading implementation.

Answer 6

As long as each thread works on a specific segment of the array then the updates should be fine. Addiontally you can definitely see a performance boost by dividing the work. You'll probably want to test the level of the boost, by testing with a different number of threads. Probably should start at 16 since you have 16 CPU, and see how increasing and decreasing effects performance.

One issue you may have is with visibility. I don't believe the elements of the array are guaranteed to be seen by all threads because they aren't volatile. So if sections of the array need to be accessed by multiple threads then you could have an issue. One way to deal with this is to use a AtomicIntegerArray... AtomicReferenceArray.