C multithreading learning note 2

Thread visible

AllocateDataSlot、SetData、 GetData

variable var => thread t1,t2
(1) t1,t2 share var => public Yes “ lock ” The problem of
(2) t1,t2 Each has a var => internal There is no lock contention problem

var slot = Thread.AllocateDataSlot("username");
// Set the slot on the main thread , in other words hello word Can only be read by the main thread , Other threads cannot read 
Thread.SetData(slot, "hello word!!");
new Thread(() => 
{
    
Thread.SetData(slot, "hello!!");
var obj = Thread.GetData(slot); 
Console.WriteLine(" Sub thread ：{0}",obj); 
}).Start();
var obj2 = Thread.GetData(slot);
Console.WriteLine(" The main thread ：{0}",obj2);
Console.ReadKey();

Output results ： Belong to the situation （2）

Performance enhanced version ：ThreadStatic

[ThreadStatic]
static string username = "??!!";
static void Main(string[] args)
{
    
username = "hello word!!";
new Thread(() =>
{
    
username = "hello!!";
Console.WriteLine(" Sub thread ：{0}", username);
}).Start();
    Console.WriteLine(" The main thread ：{0}", username);
    Console.ReadKey();
}

Running results ： Belong to the situation （2）

ThreadLocal： Also called thread visibility

ThreadLocal<string> local = new ThreadLocal<string>();
local.Value = "hello word!!";
new Thread(() =>
{
    
local.Value = "hello!!";
Console.WriteLine(" Sub thread ：{0}", local.Value);
}).Start();
Console.WriteLine(" The main thread ：{0}", local.Value);
Console.ReadKey();

Running results ： Belong to the situation （2）

summary

These data are stored in the thread environment , Is the space overhead of the thread .

Memory fence

release and debug The difference in performance

In actual projects , The release versions are release edition , instead of debug edition , because release Some code and cache optimizations have been done in , For example, some data from memory Read in the CPU In cache . This operation may bring some bug.

The following code is in release There is a problem that the main thread cannot end execution in the environment .

var isStop = false;
Thread t = new Thread(() =>
{
    
    var isSuccess = false;
    while (!isStop)
    {
    
        isSuccess = !isSuccess;
    }
});
t.Start();
Thread.Sleep(1000);
isStop = true;
t.Join();
Console.WriteLine(" End of main thread execution ");
Console.ReadKey();

From the code, it can be found that two threads are sharing one isStop Variable , And threads t This variable will be loaded into CPU Cache in , When the main thread pair isStop After modification , Threads t Can't perceive .
Two solutions ：
1． Don't let multiple threads operate on a shared variable , Otherwise, it is easy to have problems .
2． If it has to be done , You do not need to cache , Every time from memory Read data from .

MemoryBarrier and VolatileRead

All memory writes prior to this method should be made from CPU Cache Update to memory, All memory reads after this method are from memory Read in instead of CPU Cache.
MemoryBarrier：

var isStop = false;
Thread t = new Thread(() =>
{
    
    var isSuccess = false;
    while (!isStop)
    {
    
       Thread.MemoryBarrier();
       isSuccess = !isSuccess;
    }
});
t.Start();
Thread.Sleep(1000);
isStop = true;
t.Join();
Console.WriteLine(" End of main thread execution ");
Console.ReadKey();

VolatileRead：

var isStop = 0;
Thread t = new Thread(() =>
{
    
   var isSuccess = false;
   while (isStop != 1)
   {
       
      Thread.VolatileRead(ref isStop);
      isSuccess = !isSuccess;
   }
});
t.Start();
Thread.Sleep(1000);
isStop = 1;
t.Join();
Console.WriteLine(" End of main thread execution ");
Console.ReadKey();