object类型和多线程有什么关系哈?

Question

//有"同步"和"异步"两个版本类型的类:
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);

Answer 1

//拥有类的原子功能的类中,private object _shareState = new object(); //用于锁定线程.
//这样可以.但是如果这样:
private ShareState _shareState = new ShareState(); //用于锁定线程.
//问题很严重,内存严重溢出...我的VS2010都自动关闭...
//但是锁定不一定要是object类型哈...比如我在上面第"25"行中,
// private object syncRoot = new object(); //用于同步的对象.
//改为 Demo类型,即 private Demo syncRoot = new Demo();
//又没事...貌似object和多线程...有什么联系比较特殊...这是什么原因哈....

Answer 2

你这两个都有问题，private object syncRoot，这个都是私有的，如果重复创建类实例，不同实例之间根本就达不到lock功能，一般要在多个实例间同步枷锁，object要声明为static 静态类型，自始至终只有一个，不会因为每次创建一个类实例，都要new一个object

Answer 3

In general, avoid locking on a public type, or instances beyond your code's control. The common constructs lock (this), lock (typeof (MyType)), and lock ("myLock") violate this guideline:•lock (this) is a problem if the instance can be accessed publicly.•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的解释。

Answer 4

线程A，"其他人有没有人在调用这个方法啊~?" 没有人回答，
自己看看object有没有被锁，从而得出别人是否在调用方法线程B，"其他人有没有人在调用这个方法啊~?" 没有人回答，
自己看看object有没有被锁，从而得出别人是否在调用方法为什么要用静态的呢~ 如果每个实例都自己有，然后锁他，和别人没有关系
所以要所有人挑一个公共的来，如2楼所说

Answer 5

晕...版主你没有看好吧...我的实例(即我用来锁线程的实例)是private的...当然不会是用外面的实例去lock哈...这应该不是问题...

Answer 6

晕...版主你没有看好吧...我的实例(即我用来锁线程的实例)是private的...当然不会是用外面的实例去lock哈...这应该不是问题...
我看错了...

Answer 7

哦...也就是说我的问题就是:
•lock (typeof (MyType)) is a problem if MyType is publicly accessible.
是吧....
呵呵..我找到那个　ＭＳＤＮ　解释的页面了．．．

Answer 8

哦...也就是说我的问题就是:
•lock (typeof (MyType)) is a problem if MyType is publicly accessible.
是吧....
呵呵..我找到那个　ＭＳＤＮ　解释的页面了．．．
是的，不能用本身的类型，还担心需不需要给你翻译呢，看来不要了。
MSDN有列出三个常见的错误。