Re: What is the closest to ConcurrentHashMap and NavigableMap in Java?

[Jacek Furmankiewicz]

On Friday, 15 November 2013 at 07:42:22 UTC, ilya-stromberg wrote:
On Thursday, 14 November 2013 at 22:12:10 UTC, Jacek 
Furmankiewicz wrote:
On Thursday, 14 November 2013 at 21:36:46 UTC, ilya-stromberg 
wrote:
On Thursday, 14 November 2013 at 21:31:52 UTC, Jacek 
Furmankiewicz wrote:
How often do you change the data? Probably, you should use 
`immutable` variables.

Customer specific. It may change once a year. It may change 
multiple times per second for a while, then nothing again for 
weeks.

Others may do mass loads of business rules, hence do mass 
changes every few hours.

Next to impossible to predict.

You can use `immutable` variables. It allows you to share the 
data without any synchronization. Like this:

class MyData
{
   int data1;
   string data2;

   //creates new object
   this(int data1, string data2)
   {
      this.data1 = data1;
      this.data2 = data2;
   }

   //modify the data
   immutable(MyData) editData(int i) const
   {
      //copy this object - we can't change immutable variables
      MyData dataCopy = new MyData(this.data1, this.data2)

      //modify the data copy
      dataCopy.data1 += i;

      //assume that `dataCopy` is immutable
      return cast(immutable(MyData)) dataCopy;
   }
}

shared myMap;

//map implementation
synchronized class MyMap
{
   HashMap!(int, immutable(MyData)) map;

   void foo()
   {
      map[1] = new immutable MyData(1, "data");
   }

   void bar()
   {
      map[1] = map[1].editData(5);
   }
}

//init map
shared static this()
{
   myMap = new MyMap();
}

void main()
{
   myMap.foo();
   myMap.bar();
}


So what happens when the "write" operation is doing

 map[1] = map[1].editData(5);

and at the same time 50 threads are simultaneously reading the 
value in map[1]?.

Is that reassignment operation thread safe?
Or would I get corrupted reads with potentially a partially 
overriden value?

Jacek