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);

[解决办法]
你这两个都有问题，private object syncRoot，这个都是私有的，如果重复创建类实例，不同实例之间根本就达不到lock功能，一般要在多个实例间同步枷锁，object要声明为static 静态类型，自始至终只有一个，不会因为每次创建一个类实例，都要new一个object
[解决办法]
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的解释。
[解决办法]
线程A，"其他人有没有人在调用这个方法啊~?" 没有人回答，
自己看看object有没有被锁，从而得出别人是否在调用方法

线程B，"其他人有没有人在调用这个方法啊~?" 没有人回答，
自己看看object有没有被锁，从而得出别人是否在调用方法

为什么要用静态的呢~ 如果每个实例都自己有，然后锁他，和别人没有关系
所以要所有人挑一个公共的来，如2楼所说
[解决办法]

引用:

Quote: 引用:

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的解释。

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

是的，不能用本身的类型，还担心需不需要给你翻译呢，看来不要了。
MSDN有列出三个常见的错误。