object类型和多线程有什么关系哈?
//有"同步"和"异步"两个版本类型的类:
class Demo {
private ShareState _state;
public Demo() {
}
public Demo(ShareState state) {
this._state = state;
}
public virtual void DoTheJob() { //异步方法.
for(int i = 0; i < 50000; i++) {
//lock(_state) //记住在这里也要同步(一个任务不一定是一个线程).
_state.IncreaseState();
}
}
public static Demo Synchronized(Demo demo) { //同步对象.
if(!demo.IsSynchronized) return new SynchronizationDemo(demo);
return demo;
}
public virtual bool IsSynchronized { //异步属性.
get { return false; }
}
private class SynchronizationDemo : Demo {
private object syncRoot = new object(); //用于同步的对象.
private Demo d;
public override bool IsSynchronized { //同步属性.
get {
return true;
}
}
public override void DoTheJob() { //同步方法.
lock(syncRoot) {
d.DoTheJob();
}
}
public SynchronizationDemo(Demo d) {
this.d = d;
}
}
}
//拥有类原子功能的类:
class ShareState { //原子功能.
private object _shareState = new object(); //用于锁定线程.
private int _state = 0;
public int State {
get { return _state; }
}
public int IncreaseState() {
lock(_shareState)
return ++_state;
}
}
//Call in the Main:
//同步方式:
ShareState state = new ShareState(); //用于同步(锁定)的对象.
int numTask = 20;
Task[] tasks = new Task[numTask]; //任务数组.
for(int i = 0; i < tasks.Length; i++) {
Demo d = new Demo(state);
d = Demo.Synchronized(d); //同步对象.
tasks[i] = new Task(d.DoTheJob);
tasks[i].Start();
}
//for(int i = 0; i < tasks.Length; i++)
// tasks[i].Wait();
Task.WaitAll(tasks);
Console.Write(state.State);
?lock (typeof (MyType)) is a problem if MyType is publicly accessible.
?lock("myLock") is a problem because any other code in the process using the same string, will share the same lock.
Best practice is to define a private object to lock on, or a private static object variable to protect data common to all instances.
这个是MSDN的解释。
[解决办法]
线程A，"其他人有没有人在调用这个方法啊~?" 没有人回答，
自己看看object有没有被锁，从而得出别人是否在调用方法
线程B，"其他人有没有人在调用这个方法啊~?" 没有人回答，
自己看看object有没有被锁，从而得出别人是否在调用方法
为什么要用静态的呢~ 如果每个实例都自己有，然后锁他，和别人没有关系
所以要所有人挑一个公共的来，如2楼所说
[解决办法]