尽量的避免问题，我们最好不要在线程之间共享数据。如果要共享数据，就必须使用同步技术：确保一次只有一个线程访问和改变共享数据。其中不可避免的要用到“锁”。使用锁是需要时间的，并且，也不是总是必须的。所以对于一个类，我们可以创建一个类的2个版本，一个同步版本，一个异步版本。下面请看这个例子：

        public class SynDemo
        {
            public virtual bool IsSynchronized
            {
                get { return false; }
            }

            public virtual void doThis()
            {
                //dothis
            }

            public virtual void doThat()
            {
                //doThat
            }

            public static SynDemo SynchronizeDemo(SynDemo d)
            {
                if (!d.IsSynchronized)
                {
                    return new SynchronizedDemo(d);
                }
                return d;
            }

                    private class SynchronizedDemo : SynDemo
                    {
                        private SynDemo _demo;
                        private object _synRoot =new object();

                        public SynchronizedDemo(SynDemo d)
                        {
                            this._demo = d;
                        }

                        public override bool IsSynchronized
                        {
                            get
                            {
                                return true;
                            }
                        }

                        public override void doThat()
                        {
                            lock(_synRoot)
                            {
                                _demo.doThat();
                            }
                        }

                        public override void doThis()
                        {
                            lock(_synRoot)
                            {
                                _demo.doThis();
                            }
                        }

                    }
        }