java单例模式之懒汉式与饿汉式

首先我们介绍一下单例模式

1. 单例类是只有一个实例对象；
2. 该单例对象必须由单例类自行创建；
3. 单例类对外提供一个访问该单例的全局访问点。

单例模式的优点

1. 单例模式可以保证内存里只有一个实例，减少了内存的开销。
2. 可以避免对资源的多重占用。
3. 单例模式设置全局访问点，可以优化和共享资源的访问。

什么时候用到单例模式

1. 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC（垃圾回收）。
2. 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
3. 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

单例模式的创建：

饿汉式：

1.创建一个类 然后对类里面的构造器进行私有化 目的：防止外面调用该类创建对象 无法实现单例

2.一开始先创建一个静态对象 目的：这个对象就是单例

3.创建一个pubilc静态方法来返回对象,供外面调用该对象

代码如下：

//所谓的单例模式就是采取一定的方法保证整个系统软件中，对某个类实例只能存在单个类实例
public class SingletonTest1 {
    public static void main(String[] args){
        Bank bank1=Bank.getInstance();//通过调用内部类的方法 从而调用该对象
        Bank bank2=Bank.getInstance();//两个对象都是一样的

        System.out.println(bank1 == bank2);
    }

}
//饿汉式模式
class Bank{
    //私有化类的构造器  目的：防止外面调用造对象  如果不将其定义成私有的
    // 那么便可以在外面不断的创建类对象 无法做到只有一个对象
    private Bank(){

    }
    //内部创建类的对象 要求此对象必须为静态  目的:在内部创建对象
    //为了能够对象  因为外面不能创建该类的对象
    private static Bank instance = new Bank();
    //但是为了使外部能够调用到该对象我们必须提供一个静态方法让外部调用
    //提供公共的静态方法，返回类对象
    public static Bank getInstance(){
        return instance;
    }
}

 说明这个两个对象是一样的。

以上就是饿汉式的单例模式 ：

优点：线程安全的

不足：一开始就创建对象容易造成空间浪费

懒汉式：

1.创建一个类 并将构造器设置为私有的 目的：防止外面的对象去调用 无法弄成单例模式

2.声明一个静态对象 但是没有初始化  等到要使用的时候再去初始化对象 避免占用内存空间

3.提供一个public static 方法供外面调用

代码如下：

public class SingletonTest2 {
    public static void main(String[] args){
        order order1=order.getInstance();
        order order2=order.getInstance();

        System.out.println(order1==order2);
    }

}

//懒汉式
class order{
    //1.私有化类的构造器 目的：为了不让在外面创建对象
    private order(){

    }
    //2.声明当前对象，没有初始化
    //4.此对象必须为静态
    private static order instance =null;//先设置为空 等要使用的时候再去创建对象
    //3.声明public、static返回当前对象的方法 目的：为外部调用提供方法  不然外部无法调用
    public static order getInstance(){
        if(instance==null){//这时如果有两个线程同时调用该方法  在这里面有可能出现线程的阻塞问题 导致创建出不同的对象
            instance=new order();
        }
        return instance;
    }

}

上面就是懒汉式的单例模式

优点：避免内存空间浪费

不足：线程不安全  当多个线程同时调用的时候方法内部可能会发生阻塞 造成线程不安全

下面我们写一个线程安全的懒汉式模式：

class Bank1{
    private Bank1(){

    }
    private static Bank1 instance=null;
    public static Bank1 getInstance(){
        //方式一：效率稍差
//        synchronized (Bank1.class){
//            if(instance==null){
//                instance=new Bank1();
//            }
//            return instance;
//        }
        //方式二:效率稍好
        if(instance==null){
            synchronized (Bank1.class){
                if(instance==null){
                    instance=new Bank1();
                }
            }
        }
        return instance;
    }

}
public class SingletonSafeTest2 {
    public static void main(String[] args){
        Bank1 b1=Bank1.getInstance();
        Bank1 b2=Bank1.getInstance();
        System.out.println(b1==b2);
    }
}

上面我们使用同步代码块的方法将懒汉式线程不安全变成了线程安全。

以上就是关于单例模式之懒汉式与饿汉式的介绍  不足之处望各位大佬指教