xiaoemo0 2019-11-01
1. 私有构造方法;
2. 内部创建静态对象;
3. 提供静态方法返回该静态对象;
class Singleton0 { //构造方法私有化 private Singleton0() { } //内部创建静态对象并实例化 private static Singleton0 s=new Singleton0(); //提供静态方法返回该静态对象 public static Singleton0 getsingle() { return s; } }
class Singleton1{ //构造方法私有化 private Singleton1() { } //内部创建静态对象 public static Singleton1 single=null; //提供静态方法返回该静态对象 public static Singleton1 getsingle() { //静态对象实例化 single=new Singleton1(); return single; } }
1. 线程安全:
饿汉式天生线程安全,可以直接用于多线程而不会出现问题。
懒汉式本身非线程安全,需要人为实现线程安全。
2. 资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,造成内存泄漏,但相应的,在第一次调用时速度也会更快。
懒汉式会延迟加载,加载前不占用内存,在第一次使用该单例的时候才会实例化对象,且第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。
1. 全局访问点加同步:由于synchronized是锁方法, 当两个线程都要进入getsingle()时, 只有一个能进入, 并创建出实例, 然后另外一个进入后, 判断 s不为null, 然后直接得到s。 这种做法是没有错误的. 但是由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之,不管对象有没有被创建,其余线程都只能等待这个方法的锁。
class Single1{ private Single1() { //私有构造方法 } public static Single1 s=null; public static synchronized Single1 getsingle() { s=new Single1();//实例化 return s; } }
2. 双重检查锁定:由于上述都是在等待同步方法的锁,很容易想到把synchronized放在方法里面,这样可以避免方法的阻塞。
class Single2{ private Single2() { //私有构造方法 } public static Single2 s=null; public static Single2 getsingle() { if(s==null) { synchronized(Single2.class) { s=new Single2();//实例化 } } return s; } }
这种写法看似没有问题, 其实却有一个很大的隐患, 在于:如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null,所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:
class Single3{ private Single3() { //私有构造方法 } public static Single3 s=null; public static Single3 getsingle() { if(s==null) { synchronized(Single3.class) { if(s==null) { s=new Single3();//实例化 } } } return s; } }
3. 静态内部类:既实现了线程安全,又避免了同步带来的性能影响。
原文:https://blog.csdn.net/sinat_33057149/article/details/78218146