c#入门-线程安全

线程不安全

int num = 0;
for (int i = 0; i < 100; i++)
{
	Task.Run(() =>
	{
		for (int i = 0; i < 100; i++)
		{
			num++;
		}
	});
}
Console.WriteLine("按下任意键");
Console.ReadKey();
Console.WriteLine(num);

创建100个任务，任务里都循环100次，对目标值+1。
按照预期，他的结果应该是10000，但实际上，结果可能缺斤少两。

造成这样的原因，举个例子

线程a过来了。看见num是31。它算出了+1后是32，但他突然很想去厕所，来不及改num。
线程b过来了，看见num是31。它也算出了是32，也突然想去厕所。
线程a回来了，把num改成了32.
线程b回来了，把num改成了32.

就这样，两次的i++操作都执行了。但由于取值，计算，赋值是三步操作。
导致一个线程取值的时候，还有一个没完成的赋值操作，那么这次取值是无意义的。

锁

使用lock语法，可以简便的实现资源占用，在解除占用之前，其他线程无法访问资源。
lock可以占用任何引用类型，而值类型会引发装箱，获取的不是原值，并且无法通过编译。

object o = new object();
int num = 0;
for (int i = 0; i < 100; i++)
{
	Task.Run(() =>
	{
		for (int i = 0; i < 100; i++)
		{
			lock (o)
			{
				num++;
			}
		}
	});
}
Console.WriteLine("按下任意键");
Console.ReadKey();
Console.WriteLine(num);

死锁

lock虽然方便，但很危险。如果用不好就会造成死锁。

object[] arr = { new object(),new object()};

for (int i = 0; i < 1000; i++)
{
	int j = i;
	Task.Run(() =>
	{
		lock (arr[j % 2])
		{
			lock (arr[(1 + j) % 2])
			{
				for (int i = 0; i < 1000; i++)
				{
					Console.Write("");
				}
			}
		}
	});
}
for (int i = 0; i < 10000; i++)
{
	Console.Write("");
}
lock (arr[0])
{
	Console.WriteLine("按下任意键");
	Console.ReadKey();
	Console.WriteLine("程序结束");
}

死锁需要两层以上的lock，并且一方的内层lock锁着另一方的外层lock资源。
于是线程A锁着线程B需要的资源，并且A也需要B锁着的资源。
而B恰好又需要A锁着的资源，如果拿不到那B也不会释放资源，导致A无法继续。A无法继续又导致B无法继续。

避免方法

lock导致死锁的条件有两个，第一个是有两层以上的lock。
虽然你能控制你的代码内只有一层lock，但说不定你自己的代码在被别人调用时，别人写了个lock，而这是你无法控制的。

第二个是相互锁着了对方可以拿到的东西。所以一个解决方法就是，不要锁任何别人可以访问的东西。
包括this（无法隐藏），和任何带有缓存机制的东西（字符串，由反射生成的东西，正则表达式等）。

原子操作

i++是分为3步的操作，因此让多线程钻了空子。
如果把他限定为只用一次就能完成的操作，那就不会出问题了。
原子，即指不可再分割。c#提供了一些操作的原子操作方法。

int num = 0;
for (int i = 0; i < 100; i++)
{
	Task.Run(() =>
	{
		for (int i = 0; i < 100; i++)
		{
			Interlocked.Increment(ref num);
		}
	});
}
Console.WriteLine("按下任意键");
Console.ReadKey();
Console.WriteLine(num);