设计模式之单例模式
具体使用案例如下:
using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleTest
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("singleton。。。");
var task = Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{SingleTon.Instance.GetHashCode()}");
})).ToArray();
Task.WaitAll(task);
//Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("SingleTon1");
Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{SingleTon1.Instance.GetHashCode()}");
})).ToList();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("SingleTon2");
Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{SingleTon2.Instance.GetHashCode()}");
})).ToList();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("SingleTon3");
Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{SingleTon3.Instance.GetHashCode()}");
})).ToList();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("SingleTon4");
Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{SingleTon4.Instance.GetHashCode()}");
})).ToList();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("SingleTon5");
SingleTon5 singleTon5 = new SingleTon5();
Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{singleTon5.AddCount()}");
})).ToList();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("SingleTon6");
SingleTon6 singleTon6 = new SingleTon6();
Enumerable.Range(1, 10).Select(i => Task.Run(() =>
{
Console.WriteLine($"{singleTon6.AddCount()}");
})).ToList();
Console.ReadLine();
}
}
/// <summary>
/// 单线程
/// </summary>
public class SingleTon
{
/// <summary>
/// 私有变量,延迟加载
/// </summary>
private static SingleTon instance = null;
/// <summary>
/// 私有构造函数,方式初始化
/// </summary>
private SingleTon()
{
}
/// <summary>
/// 公开实例,单例供外部使用
/// </summary>
public static SingleTon Instance
{
get
{
if (instance == null)
{
instance = new SingleTon();
}
return instance;
}
}
}
/// <summary>
/// 多线程
/// </summary>
public class SingleTon1
{
/// <summary>
/// 私有变量,提前初始化
/// </summary>
private static SingleTon1 instance = new SingleTon1();
/// <summary>
/// 私有构造函数,方式初始化
/// </summary>
private SingleTon1()
{
}
/// <summary>
/// 公开实例,单例供外部使用
/// </summary>
public static SingleTon1 Instance => instance;
}
/// <summary>
/// 多线程
/// </summary>
public class SingleTon2
{
/// <summary>
/// 私有变量,提前初始化
/// </summary>
private static SingleTon2 instance = null;
/// <summary>
/// 锁
/// </summary>
private static readonly object objectlock = new object();
/// <summary>
/// 私有构造函数,方式初始化
/// </summary>
private SingleTon2()
{
}
/// <summary>
/// 公开实例,单例供外部使用
/// </summary>
public static SingleTon2 Instance
{
get
{
if (instance == null)
{
lock (objectlock)
{
if (instance == null)
{
instance = new SingleTon2();
}
}
}
return instance;
}
}
}
/// <summary>
/// 多线程,并发字典
/// </summary>
public class SingleTon3
{
/// <summary>
/// 并发字典
/// </summary>
private static readonly ConcurrentDictionary<int, SingleTon3> valuePairs = new ConcurrentDictionary<int, SingleTon3>();
/// <summary>
/// 私有构造函数,方式初始化
/// </summary>
private SingleTon3()
{
}
/// <summary>
/// 公开实例,单例供外部使用
/// </summary>
//public static SingleTon3 Instance => valuePairs.GetOrAdd(1, new SingleTon3());
public static SingleTon3 Instance => valuePairs.GetOrAdd(1, k => new SingleTon3());
}
/// <summary>
/// 多线程,并发字典
/// </summary>
public class SingleTon4
{
/// <summary>
/// 并发字典
/// </summary>
//private static readonly Lazy<SingleTon4> singleTon = new Lazy<SingleTon4>();
private static readonly Lazy<SingleTon4> singleTon = new Lazy<SingleTon4>(() => new SingleTon4());
/// <summary>
/// 私有构造函数,方式初始化
/// </summary>
private SingleTon4()
{
}
/// <summary>
/// 公开实例,单例供外部使用
/// </summary>
public static SingleTon4 Instance => singleTon.Value;
}
/// <summary>
/// 多线程,原子操作
/// </summary>
public class SingleTon5
{
private int count;
public int AddCount()
{
return Interlocked.Increment(ref count);
}
}
/// <summary>
/// 多线程,同步操作
/// </summary>
public class SingleTon6
{
private volatile int count;
public int AddCount()
{
return count++;
}
}
}
运行效果如下: