Нужно ли использовать блокировки, просто присваивая переменные?

Question

Когда многопоточность я знаю, что мне нужно блокировать переменные, если вы делаете такие вещи, как добавление и элемент в список, или я получаю исключение перекрестного потока. Но нужно ли их блокировать при назначении переменных? Я не возражаю, если поток получает старый экземпляр переменной - я просто не хочу, чтобы это ошибка. Вот пример того, что я имею в виду:

public void Run() 
    { 
     var thread1 = new Thread(new ThreadStart(Test)); 
     var thread2 = new Thread(new ThreadStart(Test)); 
     thread1.Start(); 
     thread2.Start(); 
    } 

    private static int _test; 

    private void Test() 
    { 
     while (true) 
     { 
      _test += 1; 
     } 
    } 

Answer 1

Выполнение кода должно дать вам ответ ... вместо while(true) записи for(i=1;1<1e6;i++), записать результат на экран и запустить его.

Вы увидите, что это не означает 2e6, а что-то около 1.2e6. Так что да, вам нужно запереть, если вы хотите выйти 2e6.

Не просто гипотеза, после этого всегда проверяйте и утверждайте.

Answer 2

Вы должны помнить, нить также может быть глядя на несвежей копии, блокируя вас заверить, что версия переменной, которую вы смотрите на это обновляется

Когда я впервые начал кодирование и подумал, что, возможно, мне не нужна самая свежая копия переменной, которую я бы застрял в бесконечных циклах, потому что я предполагаю, что переменная будет в конечном итоге обновлена, но если переменная была кэширована, она никогда не обновлялась

Я включил примеры с краткими описаниями, не волнуйтесь о том, как поток запускается d, что не имеет отношения

private static bool _continueLoop = true; 
private static readonly object _continueLoopLock = new object(); 

private static void StopLoop() 
{ 
    lock(_continueLoopLock) 
     _continueLoop = false; 
} 

private static void ThreadALoopWillGetStales() 
{ 
    while(_continueLoop) 
    { 
     //do stuff 
     //this is not guaranteed to end 
    } 
} 

private static void ThreadALoopEventuallyCorrect() 
{ 
    while(true) 
    { 
     bool doContinue; 

     lock(_continueLoopLock) 
      doContinue = _continueLoop; 

     if(!doContinue) 
      break; 

     //do stuff 
     //this will sometimes result in a stale value 
     //but will eventually be correct 
    } 
} 

private static void ThreadALoopAlwaysCorrect() 
{ 
    while(true) 
    { 
     bool doContinue; 

     lock(_continueLoopLock) 
      if(!_continueLoop) 
      break; 

     //do stuff 
     //this will always be correct 
    } 
} 

private static void ThreadALoopPossibleDeadlocked() 
{ 
    lock(_continueLoopLock) 
     while(_continueLoop) 
     { 
      //if you only modify "_continueLoop" 
      //after Acquiring "_continueLoopLock" 
      //this will cause a deadlock 
     } 
} 

private static void StartThreadALoop() 
{ 
    ThreadPool.QueueUserWorkItem ((o)=>{ThreadALoopWillGetStales();}); 
} 
private static void StartEndTheLoop() 
{ 
    ThreadPool.QueueUserWorkItem((o)=> 
    { 
     //do stuff 
     StopLoop(); 
    }); 
} 

public static void Main(string[] args) 
{ 
    StartThreadALoop(); 
    StartEndTheLoop(); 
} 

при запуске цикла есть шанс, что вы будете продолжать получать устаревшую копию переменного, поэтому вы сделать нужно какое-то синхронизацию при доступе к через несколько потоков

Answer 3

Если вы всего лишь , назначивint, тогда нет. Но здесь вы не просто назначаете. Вы увеличиваетесь. Поэтому вам нужна какая-то синхронизация.

В вы хотите увеличить, используйте Interlocked.Increment:

Interlocked.Increment(ref _test);