C#线程系列讲座(4):同步与死锁
虽然线程可以在一定程度上提高程序运行的效率,但也会产生一些副作用。让我们先看看如下的代码:
{
private int n = 0;
private int max;
public Increment(int max)
{
this.max = max;
}
public int result
{
get
{
return n;
}
set
{
n = value;
}
}
public void Inc()
{
for (int i = 0; i < max; i++)
{
n++;
}
}
}
class Program
{
public static void Main()
{
Increment inc = new Increment(10000);
Thread[] threads = new Thread[30];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread(inc.Inc);
threads[i].Start();
}
for (int i = 0; i < threads.Length; i++)
{
threads[i].Join(); // 等待30个线程都执行完
}
Console.WriteLine(inc.result); //输出n的值
}
}
上面的程序的基本功能是使用Increment的Inc方法为n递增max,所不同的是,将在Main方法中启动30个线程同时执行Inc方法。在本例中max的值是10000(通过Increment的构造方法传入)。读者可以运行一下这个程序,正常的结果应该是300000,但通常不会得到这个结果,一般获得的结果都比300000小。其中的原因就是Inc方法中的n++上,虽然从表面上看,n++只是一条简单的自增语言,但从底层分析,n++的IL代码如下:
ldsfld // 获得n的初始值,并压到方法栈中
ldc.i4.1 // 将1压到方法栈中
add // 从方法栈中弹出最顶端的两个值,相加,然后将结果保存在方法栈中
stfld // 从当前方法栈中弹出一个值,并更新类字段n
对于上面每一条IL语句是线程安全的,但是n++这条C#语句需要上面的四步才能完成,因此,n++这条语句并不是线程安全的。只要在执行stfld指令之前的任何一步由于其他线程获得CPU而中断,那么就会出现所谓的“脏”数据。
假设n的初始值为0, 在thread1在执行完ldc.i4.1后被thread2中断(add指令并未执行),这时thread2获得的n的初始值仍然是0,假设thread2顺利执行完,那么这时n的值已经是1了,当thread2执行完后,thread1继续执行add指令,并且thread1也顺利执行完,这时,在thread1中的执行结果n仍然是1。因此,这也就出现了调用两次n++,n仍然为1的情况。要解决这个问题的方法也很容易想到,就是让上述四条IL语句要不都不执行,要执行就都执行完,这有点事务处理的意思。
在C#中解决这个问题的技术叫同步。同步的本质就是为某一个代码块加锁,使其成为一个整体,共同进退。最简单的是使用lock为代码块加锁。这个语句在前几讲已经多次使用过了。lock语句可以锁定任何的对象,如果锁定的是类成员,直接使用lock(obj)的形式即可,如果锁定的是静态成员,可以把锁主在object类型上,代码如下:
lock(typeof(StaticClass))
{
... ...
}
对于Increment类,我们可以锁定n++,也可以锁定Inc方法,如锁定n++的Increment类的代码如下:
{
private int n = 0;
private int max;
private Object lockN = new Object();
public Increment(int max)
{
this.max = max;
}
public int result
{
get
{
return n;
}
set
{
n = value;
}
}
private void IncN()
{
lock (lockN)
{
n++;
}
}
public void Inc()
{
for (int i = 0; i < max; i++)
{
IncN();
}
}
}
也可以直接将如下的代码放到for循环中取代调用IncN方法,
{
n++;
}
或者直接将Inc方法锁住,代码如下:
{
lock (lockN)
{
for (int i = 0; i < max; i++)
{
n++;
}
}
}
但笔者并不建议直接将Inc锁住,因为这样就和单线程没什么区别了,虽然可以避免出现读脏数据的情况,但却牺牲的效率。
从本例分析得知,产生问题的原因就是因为n++不是原子操作。而在.net framework中提供了一个Interlocked类,可以使n++变成原子操作。Interlocked有一些方法,可以保证对变量的操作是原子的,如Increment方法保证n++的操作是原子的,Decrement方法保证n--的操作是原子的,Exchange方法保证为变量赋值的操作是原子的。因此,可以使用Increment方法来替换n++,代码如下:
{
for (int i = 0; i < max; i++)
{
Interlocked.Increment(ref n);
}
}
任何事物都具有两面性,同步技术也不例外,在某些情况下,可以由于两个线程互相锁定某些对象而造成死锁(就是两个线程互相等待对方释放对象)。这就象有两个学生晚上在复习功课,他们都希望学习能超过对方,而且他们都很累了,但是谁也不肯先休息,是都在盯着对方屋里的灯,期望着对方休息后。自己才休息。但却谁也不肯先关灯,所以他们就只有这样耗到天亮了。当然,解决这个问题的方法有两个,第一个就是其中一个学生或两个学生根本就不关心对方是否先睡觉,自己学累了就直接关灯了。当然,另外一个方法就有点暴力了,就是到点就直接断电,那谁也别学了(这也相当于线程中断,不过不到万不得以时最好别用这招)。
让我们先举一个线程死锁的例子,代码如下:
{
private static Object objA = new Object();
private static Object objB = new Object();
public static void LockA()
{
lock (objA)
{
Thread.Sleep(1000);
lock (objB)
{
}
}
Console.WriteLine("LockA");
}
public static void LockB()
{
lock (objB)
{
Thread.Sleep(2000);
lock (objA)
{
}
}
Console.WriteLine("LockB");
}
public static void Main()
{
Thread threadA = new Thread(LockA);
Thread threadB = new Thread(LockB);
threadA.Start();
threadB.Start();
}
}
在上面的代码中,LockA方法会在当前线程中执行完Lock(objA)后延迟1秒,而LockB方法会在执行完lock(objB)后延迟2秒,一般LockA会先执行lock(objB),但这时objB已经被LockB锁住了,而且LockB还在延迟(2秒还没到)。在这时,LockA已经将objA和objB都锁上了,当LockB执行到lock(objA)时,由于objA已经被锁上,因此,LockB就被阻塞了。而LockA在执行到lock(objB)时,由于这时LockA还在延迟,因此,objB也被锁住了。LockA和LockB也就相当于上述的两个学生,互相等待对方关灯,但谁也不肯先关灯,所以就死锁了。如果采用第一种方法非常简单,就是保持被锁定的多个对象的顺序,如将LockB方法的锁定顺序换一下,代码如下:
{
lock (objA)
{
Thread.Sleep(2000);
lock (objB)
{
}
}
Console.WriteLine("LockB");
}
或是将LockA方法也改一下,先锁objB,再锁objA。
当然,也可以采用暴力一点的方法,当发现一些线程长时间没反应时,可以使用Abort方法强行中断它们。代码如下:
{
Thread threadA = new Thread(LockA);
Thread threadB = new Thread(LockB);
threadA.Start();
threadB.Start();
Thread.Sleep(4000);
threadA.Abort();
threadB.Abort();
Console.WriteLine("线程全部结束");
}
在后面的文章中将讲解C#中其他的同步技术。
下一篇:C#线程系列讲座(5):同步技术之Monitor
C#线程系列讲座(4):同步与死锁相关推荐
- 036-2018-1028 线程 效率对比 数据共享 同步锁死锁递归锁 守护线程 信号量
笔记 昨日内容回顾: 队列:Queue 管道 : Pipe ,recv消息的时候 OSError,EOFError,数据不安全的 Manager : 共享数据 , 数据不安全 , 加锁 进程池 : P ...
- C#线程系列讲座(5):同步技术之Monitor
在上一讲介绍了使用lock来实现线程之间的同步.实际上,这个lock是C#的一个障眼法,在C#编译器编译lock语句时,将其编译成了调用Monitor类.先看看下面的C#源代码: public sta ...
- C#线程系列讲座(1):BeginInvoke和EndInvoke方法
本文是转载,原文地址:http://www.itpub.net/thread-1021075-1-1.html 几个关键词:IAsyncResult,isComplete,asyncResult.As ...
- C#线程系列讲座(3):线程池和文件下载服务器
如果设计一个服务器程序,每当处理用户请求时,都开始一个线程,将会在一定程序上消耗服务器的资源.为此,一个最好的解决方法就是在服务器启动之前,事先创建一些线程对象,然后,当处理客户端请求时,就从这些建好 ...
- Python 多线程总结(2)— 线程锁、线程池、线程数量、互斥锁、死锁、线程同步
主要介绍使用 threading 模块创建线程的 3 种方式,分别为: 创建 Thread 实例函数 创建 Thread 实例可调用的类对象 使用 Thread 派生子类的方式 多线程是提高效率的一种 ...
- java同步与死锁_Java多线程 - 线程同步与死锁
一.线程同步 1)模拟多个用户同时从银行账户里面取钱 ● Account 类:银行账户类,里面有一些账户的基本信息,以及操作账户信息的方法 //模拟银行账户 classAccount {private ...
- Java 线程同步与死锁 学习笔记
Java 线程同步与死锁 学习笔记 Java 线程同步与死锁 学习笔记 1 多线程共享数据 2 线程同步 3 同步准则 4 线程死锁 1. 多线程共享数据 在多线程操作中,多个线程可能同时处理同一个资 ...
- 黑马毕向东Java课程笔记(day11):多线程(第一部分)——进程与线程+线程创建+线程安全与同步代码块+同步锁/死锁
多线程好文:添加链接描述 锁机制:synchronized.Lock.Condition.volatile(原子性可见性)--参考添加链接描述 1.进程与线程概述 首先,对于CPU执行每一个程序, ...
- C# 线程、任务和同步
1,线程概述 线程是程序汇中独立的指令流.线程有一个优先级,实际上正在处理的程序的位置计数器,一个存储其局部变量的栈.每个线程都有自己的栈.但应用程序的内存和堆由一个进程的所有线程共享. 进程包含资源 ...
最新文章
- HDU 1248 寒冰王座(全然背包:入门题)
- BlueZ--内核层+应用层
- 【编译原理】让我们来构建一个简单的解释器(Let’s Build A Simple Interpreter. Part 6.)(python/c/c++版)(笔记)
- 基于chrome内核的.NET开发资源
- 学java需要什么基础_学java需要什么基础?
- .NET正则表达式使用高级技巧之替换类
- iphone11右上角信号显示_iOS 11信号显示栏变了!这意味着啥?
- C语言之预处理探究(三):头文件包含
- 如何精简持仓基金数量?
- MVC的Filter应用小结
- ai人工智能写歌词app,ai写歌词网站,ai作词软件创作版,作词人的辅助工具,押韵助手
- MATLAB中求矩阵的逆矩阵方法(2种)
- chrome浏览器无法访问此网站并且响应时间长的方法
- 关于通过前端xslx解析excel日期格式数据转化问题以及自定义时间格式YYYY-MM-DD转化
- Word处理控件Aspose.Words功能演示:使用 C# 将 Word 文档转换为 Markdown
- 分布式架构、大数据、机器学习、搜索、推荐、广告
- 如何三平台win/安卓/ios同步日历日程
- 自媒体如何快速涨粉?除了互粉还有这3个方法,能轻松上手
- MySQL数据库与登录注册
- visualassist飞鸟的专栏