设计模式笔记----单例设计模式

一，静态常量饿汉式

1.所谓类的单例设计模式，就是采用一定的方法保证在整个系统软件中，对某个类只能实例化一个对象，并且该类只提供一个取得其对象实例的方法(静态方法)

2.步骤

<1>构造器私有化

<2>类的内部创建对象

<3>向外暴露一个静态的公共方法

<4>代码

package 设计模式.单例设计模式.静态常量饿汉式;

import javax.print.attribute.standard.Finishings;

public class Test1 {
    public static void main(String []args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}
class Singleton{
    //1构造器私有化
    private Singleton(){

    }
    //本类内部创建实例
    private final static Singleton simple=new Singleton();
    //提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return simple;
    }
}

<5>分析

优点:写法简单，就是在类加载的时候实现实例化，避免了线程同步问题

缺点:在类加载的时候就实现实例化可能会导致资源浪费

二，静态代码快饿汉式

package 设计模式.单例设计模式.静态代码快饿汉式;

public class Test1 {
    public static void main(String []args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}
class Singleton{
    private  Singleton(){
        
    }
    private static Singleton singleton;
    static{
        singleton=new Singleton();
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

三，线程不安全懒汉式

1.代码

package 设计模式.单例设计模式.线程不安全懒汉式;

public class Test1 {
    public static void main(String []args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.print("sdas"+(singleton1==singleton2));
    }
}
class Singleton{
    private static Singleton singleton;
    private Singleton(){}
    //提供一静态的公有方法
    public static Singleton getInstance(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

2.优缺点分析

优点:起到了懒加载的效果，与饿汉式相比改善了资源浪费的缺点

缺点：只能在单线程下使用，如果在多线程下使用，一个线程进入到if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时就会产生多个实例

四，线程安全懒汉式

1.代码

package 设计模式.单例设计模式.线程安全懒汉式;

import com.sun.org.apache.xpath.internal.axes.SelfIteratorNoPredicate;

public class Test1 {
    public static void main(String []args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println("");
    }
}
class Singleton{
    private static Singleton singleton;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

2.优缺点分析

优点:解决了线程安全问题

缺点:效率太低

五，双重检查

1.代码

package 设计模式.单例设计模式.双重检查;

public class Test1 {
    public static void main(String []args){
        Thread2 thread2 =new Thread2();
        new Thread(thread2).start();
        Thread1 thread1=new Thread1();
        new Thread(thread1).start();
    }
}
class Thread1 implements Runnable{
    public static Singleton singleton;
    @Override
    public void run() {
        int t=100;
        while(t>0){
            singleton=Singleton.getInstance();
            System.out.println(singleton==Thread2.singleton);
            t--;
        }
    }
}
class Thread2 implements Runnable{
    public static Singleton singleton;
    @Override
    public void run() {
        int t=100;
        while(t>0){
            singleton=Singleton.getInstance();
            t--;
        }
    }
}
class Singleton{
    private static volatile Singleton singleton;
    private Singleton() {

    }
    public static Singleton getInstance(){
        if(singleton==null){
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

2.优缺点

优点:保证了线程安全，同时效率也比较高

六，静态内部类

1.代码

package 设计模式.单例设计模式.静态内部类;

public class Test {
    public static void main(String []args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}
class Singleton{
    //private static volatile Singleton singleton;
    private static class SingleDemo{
        private static final Singleton sinple=new Singleton();
    }
    public static synchronized Singleton getInstance(){
        return SingleDemo.sinple;
    }
}

七，枚举

1.代码

package 设计模式.单例设计模式.枚举;

public class Test {
    public static void main(String []args){
        Singleton singleton1=Singleton.INSTANCE;
        Singleton singleton2=Singleton.INSTANCE;
        System.out.println(singleton1==singleton2);
    }
}
enum Singleton{
    INSTANCE;
    public void sayOk(){
        System.out.println("ok");
    }
}

2.优缺点

优点:避免了多线程同步问题，同时防止反序列化重新创建新的对象