单例模式

package singleton;

/**
 * 单例模式的特点
 * 1.内存中只有一个实例
 * 2.只能自己创建自己的实例
 * 3.给其他对象提供自己的实例
 */
public class Singleton1 {

    private static Singleton1 singleton = new Singleton1();

    private Singleton1(){

    }

    public static Singleton1 getInstance(){
        return  singleton;
    }

}

package singleton;

/**
 * 单例模式的特点
 * 1.内存中只有一个实例
 * 2.只能自己创建自己的实例
 * 3.给其他对象提供自己的实例
 */
public class Singleton2 {

    private static Singleton2 singleton;

    /**
     * Singleton1 如果不使用该对象浪费内存，
     * 所以不让singleton随着类的加载而创建对象
     * 而是调用getInstance()的时候在创建对象
     */
    private Singleton2() {
        if (singleton == null) {
            singleton = new Singleton2();
        }
    }

    public static Singleton2 getInstance() {
        return new Singleton2();
    }

}

package singleton;

/**
 * 单例模式的特点
 * 1.内存中只有一个实例
 * 2.只能自己创建自己的实例
 * 3.给其他对象提供自己的实例
 */
public class Singleton3 {

    private static Singleton3 singleton ;


    private Singleton3(){
        if(singleton==null){
            singleton =new Singleton3();
        }
    }
    /**
     * Singleton2 存在现线程安全问题，所以添加了synchronized
     * 例如线程a执行完 if(singleton==null)，线程执行权被线程b抢走
     * 线程b在判断if(singleton==null)的时候，依然为true，所以线程a和线程b new了两次对象
     */
    public synchronized  static  Singleton3 getInstance(){
        return  new Singleton3();
    }

}

package singleton;

import com.sun.deploy.util.StringUtils;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.Arrays;
import java.util.Date;

/**
 * 单例模式的特点
 * 1.内存中只有一个实例
 * 2.只能自己创建自己的实例
 * 3.给其他对象提供自己的实例
 */
public class Singleton4 {

    private static Singleton4 singleton ;

    private Singleton4(){
        if(singleton==null){

            synchronized (Singleton4.class){

                    singleton =new Singleton4();

            }
        }
    }

    /**
     * Singleton3 因为在getInstance()方法上添加了synchronized所以会有效率问题
     * 例如线程a在getInstance()的时候，线程b也要getInstance()，
     * 线程b就必须得等线程a执行完getInstance()才能执行getInstance()。降低了效率不好
     * 所以将锁移动到构造函数中的if下面，对象等于的空的时候才加锁创建对象
     * @return
     */
    public   static Singleton4 getInstance(){
        return  new Singleton4();
    }

}

package singleton;

/**
 * 单例模式的特点
 * 1.内存中只有一个实例
 * 2.只能自己创建自己的实例
 * 3.给其他对象提供自己的实例
 */
public class Singleton5 {

    private static Singleton5 singleton ;

    private Singleton5(){
        if(singleton==null){
            synchronized (Singleton5.class){
                if(singleton==null){
                    singleton =new Singleton5();
                }
            }
        }
    }

    /**
     *Singleton4依然存在线程安全问题
     * 例如：线程a运行到synchronized (Singleton5.class)线程的执行权被线程b抢走，执行完 singleton =new Singleton5();
     * 当线程b抢到执行权时继续执行synchronized (Singleton5.class)内容，所以singleton =new Singleton5();被执行了两次
     * 因此在synchronized (Singleton5.class)同步锁里面添加if(singleton==null)判断
     *
     *
     * @return
     */
    public   static Singleton5 getInstance(){
        return  new Singleton5();
    }

}