zzreo
← 全部文章

单例模式-懒汉与饿汉

本文目录
  1. 饿汉单例
  2. 懒汉单例
  3. 饿汉式和懒汉式的区别
    1. 线程安全:
    2. 资源加载和性能:

饿汉单例

public class MyInstance {
    private static final MyInstance instance = new MyInstance();
    private MyInstance(){//私有构造方法,不允许在进行new对象
    }

    public static MyInstance create(){
        return instance;
    }
}

懒汉单例


public class Single0 {
	private Single0() {
		//私有构造方法
	}
	private static Single0 s=new Single0();//内部创建静态方法,实例化
	public static Single0 getsingle() {
		return s;//提供静态方法,返回对象
	}
}

上面的代码是有问题的,多线程问题:如果多个线程访问就可能会出现new出多个实例

完美懒汉代码

public class MyInstance4 {
    private volatile static MyInstance4 instance;
    private MyInstance4(){
        System.out.println("new Instance");
    }
     //这种方式效率低下,在方法上加锁
   /* public  static synchronized MyInstance4 create(){
        if(instance==null){
            instance = new MyInstance4();
        }
        return instance;
    }*/
    //双重检查锁定
    public  static  MyInstance4 create(){
        if(instance==null){
            synchronized (MyInstance4.class){
                if(instance==null)
                    instance = new MyInstance4();
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        for (int i = 0; i < 999999; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    create();
                }
            }).start();
        }
    }
}

饿汉式和懒汉式的区别

  1. 线程安全:

  • 饿汉式天生线程安全,可以直接用于多线程而不会出现问题。

  • 懒汉式本身非线程安全,需要人为实现线程安全。

  1. 资源加载和性能:

  • 饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,造成内存泄漏,但相应的,在第一次调用时速度也会更快。

  • 而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了