以下是调用Counter类的客户程序，在这里我们定义了四个线程同时使用计数器，每个线程使用4次，最后得到的正确结果应该是16：

using System;
using System.IO;
using System.Threading;
namespace csPattern.Singleton.MutileThread
...{
public class MutileClient
...{
public MutileClient() ...{}
public void DoSomeWork()
...{
Counter myCounter = Counter.instance(); //方法一
//Counter_lazy myCounter = Counter_lazy.instance(); //方法二 
for (int i = 1; i < 5; i++)
...{
myCounter.Inc();
Console.WriteLine("线程{0}报告: 当前counter为: {1}", Thread.CurrentThread.Name.ToString(), myCounter.GetCounter().ToString());
}
}
public void ClientMain()
...{
Thread thread0 = Thread.CurrentThread;
thread0.Name = "Thread 0";
Thread thread1 =new Thread(new ThreadStart(this.DoSomeWork));
thread1.Name = "Thread 1";
Thread thread2 =new Thread(new ThreadStart(this.DoSomeWork));
thread2.Name = "Thread 2";
Thread thread3 =new Thread(new ThreadStart(this.DoSomeWork));
thread3.Name = "Thread 3";
thread1.Start();
thread2.Start();
thread3.Start();
DoSomeWork(); //线程0也只执行和其他线程相同的工作。 
}
}
}

    以下为Main函数，本程序的测试入口：

using System;
namespace csPattern.Singleton
...{
public class RunMain
...{
public RunMain() ...{}
static public void Main(string[] args)
...{
MutileThread.MutileClient myClient = new MutileThread.MutileClient();
myClient.ClientMain();
System.Console.ReadLine();
}
}
} 

    执行结果如下：

    线程Thread 1报告: 当前counter为: 2
    线程Thread 1报告: 当前counter为: 4
    线程Thread 1报告: 当前counter为: 5
    线程Thread 1报告: 当前counter为: 6
    线程Thread 3报告: 当前counter为: 7
    线程Thread 3报告: 当前counter为: 8
    线程Thread 3报告: 当前counter为: 9
    线程Thread 3报告: 当前counter为: 10
    线程Thread 0报告: 当前counter为: 1
    线程Thread 0报告: 当前counter为: 11
    线程Thread 0报告: 当前counter为: 12
    线程Thread 0报告: 当前counter为: 13
    线程Thread 2报告: 当前counter为: 3
    线程Thread 2报告: 当前counter为: 14
    线程Thread 2报告: 当前counter为: 15
    线程Thread 2报告: 当前counter为: 16

    由于系统线程调度的不同，每次的执行结果也不同，但是最终结果一定是16。

    方法一中由于实例一开始就被创建，所以instance()方法无需再去判断是否已经存在唯一的实例，而返回该实例，所以不会出现计数器类多次实例化的问题。

    使用方法二：

using System;
using System.Threading;
using System.Runtime.CompilerServices;
namespace csPattern.Singleton
...{
public class Counter_lazy
...{
static Counter_lazy uniCounter;
private int totNum = 0;
private Counter_lazy()
...{
Thread.Sleep(100); //假设多线程的时候因某种原因阻塞100毫秒 
}
[MethodImpl(MethodImplOptions.Synchronized)] //方法的同步属性 
static public Counter_lazy instance()
...{
if (null == uniCounter)
...{
uniCounter = new Counter_lazy();
}
return uniCounter;
}
public void Inc() ...{ totNum ++;}
public int GetCounter() ...{ return totNum;}
}
}

    不知道大家有没有注意到instance()方法上方的[MethodImpl(MethodImplOptions.Synchronized)] 语句，他就是同步的要点，他指定了instance()方法同时只能被一个线程使用，这样就避免了线程0调用instance()创建完成实例前线程1就来调用instance()试图获得该实例。

    根据MSDN的提示，也可以使用lock关键字进行线程的加锁，代码如下：

using System;
using System.Threading;
namespace csPattern.Singleton
...{
public class Counter_lazy
...{
static Counter_lazy uniCounter;
static object myObject = new object();
private int totNum = 0;
private Counter_lazy()
...{
Thread.Sleep(100); //假设多线程的时候因某种原因阻塞100毫秒 
}
static public Counter_lazy instance()
...{
lock(myObject)
...{
if (null == uniCounter)
...{
uniCounter = new Counter_lazy();
}
return uniCounter;
}
}
public void Inc() ...{ totNum ++;}
public int GetCounter() ...{ return totNum;}
}
} 

    lock()是对一个对象加互斥锁，只允许一个线程访问其后大括号中语句块，直到该语句块的代码执行完才解锁，解锁后才允许其他的线程执行其语句块。

    还可以使用Mutex类进行同步，定义private static Mutex mut = new Mutex();后，修改instance()如下，同样可以得到正确的结果：

static public Counter_lazy instance()
...{
mut.WaitOne();
if (null == uniCounter)
...{
uniCounter = new Counter_lazy();
}
mut.ReleaseMutex();
return uniCounter;
}

    注意的是，本例中使用方法二要更改方法一的客户程序，去掉Counter_lazy.intance()的注释，并将Counter.intance()注释。
    singleton模式还可以拓展，只要稍加修改，就可以限制在某个应用中只能允许m个实例存在，而且为m个实例提供全局透明的访问方法。