C#线程之lock
2016-07-28 19:28
465 查看
一. 为什么要lock,lock了什么?
当我们使用线程的时候,效率最高的方式当然是异步,即各个线程同时运行,其间不相互依赖和等待。但当不同的线程都需要访问某个资源的时候,就需要同步机制了,也就是说当对同一个资源进行读写的时候,我们要使该资源在同一时刻只能被一个线程操作,以确保每个操作都是有效即时的,也即保证其操作的原子性。lock是C#中最常用的同步方式,格式为lock(objectA){codeB}
。
lock(objectA){codeB} 看似简单,实际上有三个意思,这对于适当地使用它至关重要:
1. objectA被lock了吗?没有则由我来lock,否则一直等待,直至objectA被释放。
2. lock以后在执行codeB的期间其他线程不能调用codeB,也不能使用objectA。
3. 执行完codeB之后释放objectA,并且codeB可以被其他线程访问。
二. lock(this)怎么了?
我们看一个例子:
using System;
using System.Threading;
namespace Namespace1
{
class C1
{
private bool deadlocked = true;
//这个方法用到了lock,我们希望lock的代码在同一时刻只能由一个线程访问
public void LockMe(object o)
{
lock (this)
{
while(deadlocked)
{
deadlocked = (bool)o;
Console.WriteLine("Foo: I am locked :(");
Thread.Sleep(500);
}
}
}
//所有线程都可以同时访问的方法
public void DoNotLockMe()
{
Console.WriteLine("I am not locked :)");
}
}
class Program
{
static void Main(string[] args)
{
C1 c1 = new C1();
//在t1线程中调用LockMe,并将deadlock设为true(将出现死锁)
Thread t1 = new Thread(c1.LockMe);
t1.Start(true);
Thread.Sleep(100);
//在主线程中lock c1
lock (c1)
{
//调用没有被lock的方法
c1.DoNotLockMe();
//调用被lock的方法,并试图将deadlock解除
c1.LockMe(false);
}
}
}
复制代码
在t1线程中,LockMe调用了lock(this), 也就是Main函数中的c1,这时候在主线程中调用lock(c1)时,必须要等待t1中的lo
4000
ck块执行完毕之后才能访问c1,即所有c1相关的操作都无法完成,于是我们看到连c1.DoNotLockMe()都没有执行。
把C1的代码稍作改动:
class C1
{
private bool deadlocked = true;
private object locker = new object();
//这个方法用到了lock,我们希望lock的代码在同一时刻只能由一个线程访问
public void LockMe(object o)
{
lock (locker)
{
while(deadlocked)
{
deadlocked = (bool)o;
Console.WriteLine("Foo: I am locked :(");
Thread.Sleep(500);
}
}
}
//所有线程都可以同时访问的方法
public void DoNotLockMe()
{
Console.WriteLine("I am not locked :)");
}
}
复制代码
这次我们使用一个私有成员作为锁定变量(locker),在LockMe中仅仅锁定这个私有locker,而不是整个对象。这时候重新运行程序,可以看到虽然t1出现了死锁,DoNotLockMe()仍然可以由主线程访问;LockMe()依然不能访问,原因是其中锁定的locker还没有被t1释放。
关键点:
1. lock(this)的缺点就是在一个线程(例如本例的t1)通过执行该类的某个使用"lock(this)"的方法(例如本例的LockMe())锁定某对象之后, 导致整个对象无法被其他线程(例如本例的主线程)访问 - 因为很多人在其他线程(例如本例的主线程)中使用该类的时候会使用类似lock(c1)的代码。
2. 锁定的不仅仅是lock段里的代码,锁本身也是线程安全的。
3. 我们应该使用不影响其他操作的私有对象作为locker。
4. 在使用lock的时候,被lock的对象(locker)一定要是引用类型的,如果是值类型,将导致每次lock的时候都会将该对象装箱为一个新的引用对象(事实上如果使用值类型,C#编译器(3.5.30729.1)在编译时就会给出一个错误)
//上课代码
using System;
using System.Threading;
using System.Diagnostics;
namespace 线程
{
class MainClass
{
public static void Main (string[] args)
{
/*
Thread thread = new Thread (Worker);
thread.Start ();
// thread.IsBackground = true;
// Thread.Sleep (2000);
thread.Join ();
Console.WriteLine ("退出主线程");
*/
// Thread t = new Thread (new ParameterizedThreadStart(WorkPara));
// t.Name = "NewThread";
// t.Start (123);
//
//
// Console.WriteLine ("主线程ID:{0}",Thread.CurrentThread.ManagedThreadId);
// ThreadPool.QueueUserWorkItem (CallBackWorkItem);
// ThreadPool.QueueUserWorkItem (Ca
11ce9
llBackWorkItem,"work");
// Thread.Sleep (3000);
Thread t1 = new Thread (sell);
Thread t2 = new Thread (sell1);
t1.Start ();
t2.Start ();
// int x = 0;
// const int iteration = 5000000;
// Stopwatch sw = Stopwatch.StartNew ();
// for (int i = 0; i < iteration; i++) {
// x++;
// }
// Console.WriteLine ("Lost time={0}",sw.ElapsedMilliseconds);
//
// sw.Restart ();
// for (int i = 0; i < iteration; i++) {
// Interlocked.Increment (ref x);
// }
// Console.WriteLine ("Lost time={0}",sw.ElapsedMilliseconds);
}
public static void Worker(){
Thread.Sleep (1000);
Console.WriteLine ("退出子线程");
}
public static void WorkPara(Object obj){
Console.WriteLine (Thread.CurrentThread.Name);
// Thread.Sleep (500);
Console.WriteLine (obj.ToString());
Console.WriteLine ("退出子线程");
}
public static void CallBackWorkItem(Object state){
Console.WriteLine ("子线程执行");
if (state != null) {
Console.WriteLine ("ID={0}:{1}", Thread.CurrentThread.ManagedThreadId, state.ToString ());
} else {
Console.WriteLine ("ID={0}",Thread.CurrentThread.ManagedThreadId);
}
}
public static int ticket = 100;
private static Object globalObj = new object ();
public static void sell(){
while(true){
lock (globalObj) {
//try{
//Monitor.Enter(globalObj);
Thread.Sleep (1000);
if (ticket > 0) {
Console.WriteLine ("sell the {0}", ticket--);
} else {
break;
}
//}finally{
//Thread.Sleep (500);
//Monitor.Exit (globalObj);
//}
}
}
}
public static void sell1(){
while(true){
lock (globalObj) {
//Monitor.Enter(globalObj);
//Thread.Sleep (100);
if (ticket > 0) {
Console.WriteLine ("sell1 the {0}", ticket--);
} else {
break;
}
//Monitor.Exit (globalObj);
}
}
}
}
}
当我们使用线程的时候,效率最高的方式当然是异步,即各个线程同时运行,其间不相互依赖和等待。但当不同的线程都需要访问某个资源的时候,就需要同步机制了,也就是说当对同一个资源进行读写的时候,我们要使该资源在同一时刻只能被一个线程操作,以确保每个操作都是有效即时的,也即保证其操作的原子性。lock是C#中最常用的同步方式,格式为lock(objectA){codeB}
。
lock(objectA){codeB} 看似简单,实际上有三个意思,这对于适当地使用它至关重要:
1. objectA被lock了吗?没有则由我来lock,否则一直等待,直至objectA被释放。
2. lock以后在执行codeB的期间其他线程不能调用codeB,也不能使用objectA。
3. 执行完codeB之后释放objectA,并且codeB可以被其他线程访问。
二. lock(this)怎么了?
我们看一个例子:
using System;
using System.Threading;
namespace Namespace1
{
class C1
{
private bool deadlocked = true;
//这个方法用到了lock,我们希望lock的代码在同一时刻只能由一个线程访问
public void LockMe(object o)
{
lock (this)
{
while(deadlocked)
{
deadlocked = (bool)o;
Console.WriteLine("Foo: I am locked :(");
Thread.Sleep(500);
}
}
}
//所有线程都可以同时访问的方法
public void DoNotLockMe()
{
Console.WriteLine("I am not locked :)");
}
}
class Program
{
static void Main(string[] args)
{
C1 c1 = new C1();
//在t1线程中调用LockMe,并将deadlock设为true(将出现死锁)
Thread t1 = new Thread(c1.LockMe);
t1.Start(true);
Thread.Sleep(100);
//在主线程中lock c1
lock (c1)
{
//调用没有被lock的方法
c1.DoNotLockMe();
//调用被lock的方法,并试图将deadlock解除
c1.LockMe(false);
}
}
}
复制代码
在t1线程中,LockMe调用了lock(this), 也就是Main函数中的c1,这时候在主线程中调用lock(c1)时,必须要等待t1中的lo
4000
ck块执行完毕之后才能访问c1,即所有c1相关的操作都无法完成,于是我们看到连c1.DoNotLockMe()都没有执行。
把C1的代码稍作改动:
class C1
{
private bool deadlocked = true;
private object locker = new object();
//这个方法用到了lock,我们希望lock的代码在同一时刻只能由一个线程访问
public void LockMe(object o)
{
lock (locker)
{
while(deadlocked)
{
deadlocked = (bool)o;
Console.WriteLine("Foo: I am locked :(");
Thread.Sleep(500);
}
}
}
//所有线程都可以同时访问的方法
public void DoNotLockMe()
{
Console.WriteLine("I am not locked :)");
}
}
复制代码
这次我们使用一个私有成员作为锁定变量(locker),在LockMe中仅仅锁定这个私有locker,而不是整个对象。这时候重新运行程序,可以看到虽然t1出现了死锁,DoNotLockMe()仍然可以由主线程访问;LockMe()依然不能访问,原因是其中锁定的locker还没有被t1释放。
关键点:
1. lock(this)的缺点就是在一个线程(例如本例的t1)通过执行该类的某个使用"lock(this)"的方法(例如本例的LockMe())锁定某对象之后, 导致整个对象无法被其他线程(例如本例的主线程)访问 - 因为很多人在其他线程(例如本例的主线程)中使用该类的时候会使用类似lock(c1)的代码。
2. 锁定的不仅仅是lock段里的代码,锁本身也是线程安全的。
3. 我们应该使用不影响其他操作的私有对象作为locker。
4. 在使用lock的时候,被lock的对象(locker)一定要是引用类型的,如果是值类型,将导致每次lock的时候都会将该对象装箱为一个新的引用对象(事实上如果使用值类型,C#编译器(3.5.30729.1)在编译时就会给出一个错误)
//上课代码
using System;
using System.Threading;
using System.Diagnostics;
namespace 线程
{
class MainClass
{
public static void Main (string[] args)
{
/*
Thread thread = new Thread (Worker);
thread.Start ();
// thread.IsBackground = true;
// Thread.Sleep (2000);
thread.Join ();
Console.WriteLine ("退出主线程");
*/
// Thread t = new Thread (new ParameterizedThreadStart(WorkPara));
// t.Name = "NewThread";
// t.Start (123);
//
//
// Console.WriteLine ("主线程ID:{0}",Thread.CurrentThread.ManagedThreadId);
// ThreadPool.QueueUserWorkItem (CallBackWorkItem);
// ThreadPool.QueueUserWorkItem (Ca
11ce9
llBackWorkItem,"work");
// Thread.Sleep (3000);
Thread t1 = new Thread (sell);
Thread t2 = new Thread (sell1);
t1.Start ();
t2.Start ();
// int x = 0;
// const int iteration = 5000000;
// Stopwatch sw = Stopwatch.StartNew ();
// for (int i = 0; i < iteration; i++) {
// x++;
// }
// Console.WriteLine ("Lost time={0}",sw.ElapsedMilliseconds);
//
// sw.Restart ();
// for (int i = 0; i < iteration; i++) {
// Interlocked.Increment (ref x);
// }
// Console.WriteLine ("Lost time={0}",sw.ElapsedMilliseconds);
}
public static void Worker(){
Thread.Sleep (1000);
Console.WriteLine ("退出子线程");
}
public static void WorkPara(Object obj){
Console.WriteLine (Thread.CurrentThread.Name);
// Thread.Sleep (500);
Console.WriteLine (obj.ToString());
Console.WriteLine ("退出子线程");
}
public static void CallBackWorkItem(Object state){
Console.WriteLine ("子线程执行");
if (state != null) {
Console.WriteLine ("ID={0}:{1}", Thread.CurrentThread.ManagedThreadId, state.ToString ());
} else {
Console.WriteLine ("ID={0}",Thread.CurrentThread.ManagedThreadId);
}
}
public static int ticket = 100;
private static Object globalObj = new object ();
public static void sell(){
while(true){
lock (globalObj) {
//try{
//Monitor.Enter(globalObj);
Thread.Sleep (1000);
if (ticket > 0) {
Console.WriteLine ("sell the {0}", ticket--);
} else {
break;
}
//}finally{
//Thread.Sleep (500);
//Monitor.Exit (globalObj);
//}
}
}
}
public static void sell1(){
while(true){
lock (globalObj) {
//Monitor.Enter(globalObj);
//Thread.Sleep (100);
if (ticket > 0) {
Console.WriteLine ("sell1 the {0}", ticket--);
} else {
break;
}
//Monitor.Exit (globalObj);
}
}
}
}
}
相关文章推荐
- c#调用COM组件
- C#实现把指定数据写入串口
- C#动态创建button的方法
- C#中抽象方法与虚拟方法的区别
- c#中虚函数的相关使用方法
- C#实现给图片加水印的方法
- C#使用加边法计算行列式的值
- C#实现多线程的同步方法实例分析
- C#中尾递归的使用、优化及编译器优化
- C#中的delegate委托类型基本学习教程
- C#实现子窗体与父窗体通信方法实例总结
- C#通用邮件发送类分享
- 举例讲解C#中自动实现的属性
- C#中this的用法集锦
- C#数据结构之顺序表(SeqList)实例详解
- C#.NET获取拨号连接的宽带连接方法
- C#异步绑定数据实现方法
- C#实现AddRange为数组添加多个元素的方法
- C#中Equality和Identity浅析
- C#比较二个数组并找出相同或不同元素的方法