D locking strategies

[estew]

Hi All,

I'm getting myself confused with thread-safety and locking. I 
have a class something like the following small example:

class A{
     private string[] _values;

     void setValue(size_t i, string val) {_values[i] = val;}
     string getValue(size_t i) conts {return _values[i];}
     const(string)[] getValues() const {return _values;}
     void setValues(in string[] c) const {_values = c;}

// Should I avoid @property ???
     @property const(string)[] values() const {return _values;}
     @property void values(in string[] vals) {_values = vals;}
}

To make it thread safe I have removed the @property and 
getValues/setValues (those which get/set the full array). This 
allows access via setValue(i, "val") or string val = getValue(i) 
only. However, if possible I would prefer not to do this. My 
thread-safe A has become:

class A{
     private string[] _values;
     void setValue(size_t i, string val)  {_values[i] = val;}
     string getValue(size_t i) const  {return _values[i];}
}


with 3 locking attempts implemented:

1. use rwmutex to gain read/write locking on the get/set functions
2. use synchronized on the entire class?
3. use synchronized on the _values field and then each get/set 
use synchronized?

Questions:
a) What is a good way to make this thread safe? One of the three 
attempts or something else?
b) I like @property because I find it makes code easier to read 
and write. But I hear they're going out of favour. Should I drop 
using @property?

Any help is appreciated.

Thanks,
Stewart