C#

Alexander Wiseman wrote:

That being said, my original confusion remains, because it seems like, from the MSDN documentation, there is nothing required on the part of the user of the System.String class to ensure thread safety. What little I have read concerning "immutability" of the string type would support this. On the other hand, if I am doing multiple write operations and multiple read operations, is there going to be a problem?

Alexander Wiseman wrote:

Let me just make sure I have this clear with a quick example. Let us say that I have two threads, A and B, both of which have access to String someStr = "My String".

Now let's say that the processor gives a time-slice to thread A, which then reads the string. Then the processor gives a time-slice to thread B, which then changes the string from "My String" to "Your String".

If I understand you correctly, then because strings are immutable, no matter when the processor decides to temporarily stop processing on thread A, nevertheless thread A will still see the value "My String", even though thread B may have "changed" it already. Is that correct?

string someString = "My String";

someString = "Your String";

string someString = "My String";

// Just making this method up for the example.
someString.Concatenate(" and Your String");

// Output: "My String and Your String"
Console.WriteLine(someString);

string someString = "My String";

string anotherString = someString.Concatenate(" and Your String");

// Output: My String"
Console.WriteLine(someString);
// Output: My String and Your String"
Console.WriteLine(anotherString);

Alexander Wiseman wrote:

In my application, several Strings which belong to an instance of a class will be both accessed and changed from multiple threads. I can easily put a lock on them and make sure the operations do not clash, but if I do not have to waste time waiting for the lock because the type is naturally thread-safe then of course I do not want to.

Guffa wrote:

As reading and writing references are atomic, there is no need to use a lock.

if(someVolatileVariable != null)
{
   someVolatileVariable.DoSomething(); // Buggy! (in a multithreaded environement, anyways)
}

Foo someVar = someVolatileVariable;
if(someVar != null)
{
   someVar.DoSomething();
}

Tech, life, family, faith: Give me a visit.
I'm currently blogging about: Goof around music jam with my brothers (with video)
The apostle Paul, modernly speaking: Epistles of Paul

Judah Himango

if(WorkCompleted != null)
{
    WorkCompleted(this, EventArgs.Empty);
}

EventHandler handler = WorkCompleted;

if(handler != null)
{
    handler(this, EventArgs.Empty);
}

Tech, life, family, faith: Give me a visit.
I'm currently blogging about: Goof around music jam with my brothers (with video)
The apostle Paul, modernly speaking: Epistles of Paul

Judah Himango

interface IDataAccess {
   int SomeData { get; set; }
   ...
}

public class DataHandler {
   private IDataAccess dataAccess;
   public DataHandler(IDataAccess dataAccess) { this.dataAccess = dataAccess; }
   public void DoSomething() {
      // here you can access the data through the dataAccess interface:
      this.dataAccess.SomeData = 42;
   }
}

public struct SomeStruct : IDataAccess {
   public DataHandler Handler;
   public SomeStruct() {
      Handler = new DataHandler(this);
   }
   public int SomeData { get {...} set {...} }
   ...
}