/// <summary>
/// test
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
{
System.Console.WriteLine("s1和s2是同一个实例。");
}
else
{
System.Console.WriteLine("s1和s2不是同一个实例。");
}
Singleton2 s3 = Singleton2.getInstance();
Singleton2 s4 = Singleton2.getInstance();
if (s3 == s4)
{
System.Console.WriteLine("s3和s4是同一个实例。");
}
else
{
System.Console.WriteLine("s3和s4不是同一个实例。");
}
}
static void Main(string[] args)
{
Console.WriteLine($"Singleton");
Enumerable.Range(1, 5).Select(
i => Task.Run(() =>
{
Console.WriteLine($"{Singleton.GetInstance().GetHashCode()}");
})
).ToList();
//Enumerable.Range(1, 100).AsParallel().ForAll(i => { Console.WriteLine(i); });
Console.WriteLine($"Singleton1");
Enumerable.Range(1, 5).Select(i => Task.Run(() =>
{
Console.WriteLine($"{Singleton1.GetInstance().GetHashCode()}");
})).ToList();
Console.WriteLine($"Singleton2");
Enumerable.Range(1, 5).Select(i => Task.Run(() =>
{
Console.WriteLine($"{Singleton2.GetInstance().GetHashCode()}");
})).ToList();
Console.WriteLine($"Singleton3");
var ss = Enumerable.Range(1, 5).Select(i => Task.Run(() =>
{
Console.WriteLine($"{Singleton3.GetInstance().GetHashCode()}");
})).ToList();
Console.ReadLine();
}
static void punto3()
{
bool testInstance = true;
Singleton1 test11 = Singleton1.Instance;
Singleton1 test12 = Singleton1.Instance;
testInstance = (test11 == test12) ? true : false;
Console.WriteLine("Instancia 1");
Console.WriteLine("Las Intancias con iguales: " + testInstance);
Singleton2 test21 = Singleton2.Instance;
Singleton2 test22 = Singleton2.Instance;
testInstance = (test21 == test22) ? true : false;
Console.WriteLine("Instancia 2");
Console.WriteLine("Las Intancias con iguales: " + testInstance);
/* LA OPCIÓN TRES PRODUCE UN DESBORDAMIENTO Y ROMPE INMEDIATAMENTE*/
//Singleton3 test31 = Singleton3.Instance;
//Singleton3 test32 = Singleton3.Instance;
//testInstance = (test31 == test32) ? true : false;
//Console.WriteLine("Instancia 3");
//Console.WriteLine("Las Intancias con iguales: " + testInstance);
Singleton4 test41 = Singleton4.Instance;
Singleton4 test42 = Singleton4.Instance;
testInstance = (test41 == test42) ? true : false;
Console.WriteLine("Instancia 4");
Console.WriteLine("Las Intancias con iguales: " + testInstance);
}
protected override void RealTestOutPut()
{
println(Singleton1.GetInstance().ToString());
println(Singleton2.GetInstance().ToString());
println(Singleton1.GetInstance().ToString());
println(Singleton2.GetInstance().ToString());
}
//3.提供一个获取实例的方法，用public static修饰
public static Singleton2 getInstance()
{
if (instance == null)
{
instance = new Singleton2();
}
return(instance);
}
public static Singleton2 GetSingleton()
{
if (_instance == null)
{
_instance = new Singleton2();
}
return(_instance);
}
public void TestSingleton2()
{
var instance1 = Singleton2.GetInstance();
Assert.IsNotNull(instance1);
var instance2 = Singleton2.GetInstance();
Assert.AreSame(instance1, instance2);
}
public static Singleton2 GetSingleton()
{
lock (_lock) //保证线程安全
{
if (_singleton == null) //保证为空才创建
{
_singleton = new Singleton2();
}
return(_singleton);
}
}
// Lock, bir kaynağa aynı anda birden fazla thread'in erişmesini engeller.
public static Singleton2 getObject()
{
if (myObj == null)
{
lock (lockObj)
if (myObj == null)
{
myObj = new Singleton2();
}
}
return(myObj);
}
public static Singleton2 GetInstance(string name)
{
if (_instance is null)
{
lock (_lock)
{
if (_instance is null)
{
_instance = new Singleton2(name);
}
}
}
return(_instance);
}
private static void Demo(string[] args)
{
for (int i = 0; i < 1000; i++)
{
Task.Factory.StartNew(() =>
{
SinglePerson p = SinglePerson.GetInstance();
Singleton1 p1 = Singleton1.GetInstance();
Singleton2 s2 = Singleton2.GetInstance();
});
}
Console.ReadKey();
}
// //加锁保证线程安全，每次获取实例时都需要加锁，很费性能
// public static Singleton2 GetInstance()
// {
// lock (lock_object)
// {
// if (_instance == null)
// _instance = new Singleton2();
// }
// return _instance;
// }
//双重判断，既可保获取同一实例是线程安全的，也不用一直加锁影响性能
public static Singleton2 GetInstance()
{
if (_instance == null)
{
lock (lock_object)
{
if (_instance == null)
{
_instance = new Singleton2();
}
}
}
return(_instance);
}
public static Singleton2 CreateInstance()
{
if (Instance == null)
{
lock (Singleton1_lock)
{ // 保证方法快只要一个进程可进入
if (Instance == null)
{
Instance = new Singleton2();
}
}
}
return(Instance);
}
private static void RegisterStandard()
{
var singleton1 = new Singleton1();
var singleton2 = new Singleton2();
var singleton3 = new Singleton3();
Container.SetResolver <ISingleton1>(() => singleton1);
Container.SetResolver <ISingleton2>(() => singleton2);
Container.SetResolver <ISingleton3>(() => singleton3);
Container.SetResolver <ITransient1, Transient1>();
Container.SetResolver <ITransient2, Transient2>();
Container.SetResolver <ITransient3, Transient3>();
Container.SetResolver <ICombined1, Combined1>();
Container.SetResolver <ICombined2, Combined2>();
Container.SetResolver <ICombined3, Combined3>();
}
private async Task Example2()
{
var numArr = Enumerable.Range(0, 5).ToList();
var singleArr = new Singleton2[numArr.Count];
var taskList = new List <Task>();
foreach (var numitem in numArr)
{
var t = Task.Run(() => singleArr[numitem] = Singleton2.Instance);
taskList.Add(t);
}
await Task.WhenAll(taskList.ToArray());
//Singleton2.Instance = null;
Console.WriteLine("All done.");
}
public static void TestInstance2Unique()
{
for (int i = 0; i < 5; i++)
{
int threadCount = 10000;
Task <int>[] tasks = new Task <int> [threadCount];
for (int j = 0; j < threadCount; j++)
{
tasks[j] = Task.Run <int>(() =>
{
return(Singleton2.GetInstance().GetHashCode());
});
}
Task.WaitAll(tasks);
var codes = tasks.Select(t => t.Result).Distinct();
Debug.Assert(codes.Count() == 1, $"Singleton2非单例 {codes.Count()}");
}
}
private void RegisterStandard()
{
ISingleton1 singleton1 = new Singleton1();
this.container[typeof(ISingleton1)] = () => singleton1;
this.container[typeof(ITransient1)] = () => new Transient1();
this.container[typeof(ICombined1)] = () => new Combined1(singleton1, new Transient1());
ISingleton2 singleton2 = new Singleton2();
this.container[typeof(ISingleton2)] = () => singleton2;
this.container[typeof(ITransient2)] = () => new Transient2();
this.container[typeof(ICombined2)] = () => new Combined2(singleton2, new Transient2());
ISingleton3 singleton3 = new Singleton3();
this.container[typeof(ISingleton3)] = () => singleton3;
this.container[typeof(ITransient3)] = () => new Transient3();
this.container[typeof(ICombined3)] = () => new Combined3(singleton3, new Transient3());
}
public static void TestInstanceProfile()
{
int count = 100000;
long es = 0;
var watch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
var va = Singleton1.GetInstance();
}
watch.Stop();
es = watch.ElapsedTicks;
Console.WriteLine($"1 耗时 {es}");
watch.Restart();
for (int i = 0; i < count; i++)
{
var va = Singleton2.GetInstance();
}
watch.Stop();
es = watch.ElapsedTicks;
Console.WriteLine($"2 耗时 {es}");
watch.Restart();
for (int i = 0; i < count; i++)
{
var va = Singleton3.GetInstance();
}
watch.Stop();
es = watch.ElapsedTicks;
Console.WriteLine($"3 耗时 {es}");
watch.Restart();
for (int i = 0; i < count; i++)
{
var va = Singleton4.GetInstance();
}
watch.Stop();
es = watch.ElapsedTicks;
Console.WriteLine($"4 耗时 {es}");
}
public static Singleton2 Instance()
{
return(singleton2 ?? (singleton2 = new Singleton2()));
}
static Nested()
{
instance = new Singleton2();
}
//将实例化放在私有构造函数里面
private Singleton2()
{
instance = new Singleton2();
}
public Singleton2()
{
Instance = new Singleton2();
}
static void Main(string[] args)
{
var uno = Singleton2.GetInstance();
Console.WriteLine(uno.ToString());
}
