[concurrency-interest] non-concurrent collection visibility question

Valentin Kovalenko valentin.male.kovalenko at gmail.com
Sat Jan 6 12:55:06 EST 2018

By the way, could you please elaborate further and tell how exactly T2
obtains a reference to the object X (unknown from your description) that
has this final field L (i.e. final List<Buffer> buffers = new


On 6 January 2018 at 20:50, Valentin Kovalenko <
valentin.male.kovalenko at gmail.com> wrote:

> Thank you for the clarification. In this case, read actions in T2 are not
> ordered by happens-before order (HB) with the write actions in T1. And all
> these actions act on the same shared variables (fields of the list L). So
> by definition, you have a data race. And there is no guarantee that you
> will correctly read all the buffers that T1 added to the L.
> I want to add, that generally there is no guarantee that you will see a
> non-null when reading L field from T2. However is your case this field is
> final, and the semantics of a final field guarantees HB* between a write to
> the field L (T1 writes there a reference to a new ArrayList()) and a read
> of the reference from L field in T2. Unfortunately, this HB* is not
> transitive with the normal HB, hence you don't have guarantees you
> initially asked about.
> And one more thing: if you had started T2 from T1 after (in program order
> (PO)) T1 added all buffers to L, then you would have had HB between all
> actions in T1 (which are ordered in PO before the start of T2) and all
> actions in T2. But as far as I understand, your case is different and T2 is
> started not from T1.
> Regards,
> Valentin
> On 6 January 2018 at 20:07, Andriy Bukatar <buka1974 at yahoo.com> wrote:
>> Thanks Valentin.
>> Yes, the devil is in the details.
>> I could rephrase the question as follows:
>> There’s a class C containing the non-concurrent list L.
>> Thread T1 adds a few items to the list L.
>> Thread T2 starts (note it did not exist at the time when T1 was updating
>> the list L). Thread T2 gets a reference to C and iterates over its list L.
>> So “AFTER” in this case is a “wall clock distance” between the time T1
>> performs the last update to L and the time when T2 starts.
>> I know the answer to this question when T2 starts iterating over L before
>> (or at the time when) T1 performs updates to non-concurrent L - no
>> visibility guarantees whatsoever.
>> The question I suppose is whether non-existence of T2 at the time of the
>> last update to L has any impact on visibility of the contents of L.
>> Not sure if this makes it any clearer and my apologies if it does not.
>> Thank you
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20180106/7db2f351/attachment-0001.html>

More information about the Concurrency-interest mailing list