非易失性对象中的java volatile对象

Question

// structure is like this, but not exact formation.
class queue
{
    volatile List<pieceOfWork> worksWaiting;
}

List<queue> qs; //  pieceOfWork has only some primitive arrays and strings.

Is it safe to read/write(not destroy, not create) elements of "Qs" from N threads at the same time?

"WorksWaiting" is meant to synchronize between controller thread(1 or 2) and a controlled thread (N) while N controlleds reading/writing to Queues concurrently.

Deletion/creation of queue will be made of controller threads.

Thanks you.

 th read   th write 
(cpu sse) (gpu opencl executor)
 ^         ^
 |         |
 W W W W W W  ....w<--- controller thread adding new works to queue and
                                                  deleting finished ones.
                                               also splits a work item if 
                                             it is not finished in short time.

Answer 1

As long as the referece to queue doesn't change (ie you don't create and use a new queue during execution), it doesn't have to be volatile (it makes no difference). Likewise, if the reference to the list inside queue doesn't change (ie you don't create and use a new list during execution) the list doesn't have to be volatile (it also makes no difference)

What does matter is that the list is a threadsafe implementation - whose internal variables are volatile and whose code is synchronised as required etc, because it's the references the list is holding (to the work objects) and its internals that will be mutated and these changes need to be visible to all threads (volatile).

Your code is irrelevant - it's the list that needs to be threadsafe.

Answer 2

Objects are not volatile. Variables are volatile. It is safe to play with the variable worksWaiting . It is not safe to play with the object it refers to unless it is documented as thread-safe or you synchronize all access to it correctly.

Answer 3

Is it safe to read/write(not destroy, not create) elements of "Qs" from N threads at the same time?

No. Is not.

See the next situation.

Thread 1                Thread 2

qs.add(queue1);      qs.delete(queue1); 
...                  ...
qs.add(queue100);    qs.delete(queue100);

You add concurrently and delete objects to non-synchronized List .

If we assume that you both try to remove and add to the list object, you get ConcurrentModificationException because your List was not synchronized and threads will be try to work with same object. Doesn't matter which object you store in List<queue> because this list is outer object and he non-synchronized.

But. Your queue class is save-thread to the next situation :

queue qs = new queue();

and

Thread 1                                   Thread 2

qs.worksWaiting.add(pieceOfWork1);      qs.worksWaiting.delete(pieceOfWork1); 
...                                     ...
qs.worksWaiting.add(pieceOfWork100);    qs.worksWaiting.delete(pieceOfWork100);

And in this situation synchronization will works.

---

So if you want synch elements in your List you need to create a class which extends from List and synchronize add() and delete() methods.