设计模式——单例模式

设计模式分为三种类型，23种

（1）创建型模式：单例模式，抽象工厂模式，原型模式，建造者模式，工厂模式。
（2）结构型模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式。
（3）行为型模式：模板方法模式，命令模式，访问者模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式，职责链模式。

单例模式：
    介绍：采取一定的方法保证整个系统中，对某个类只能存在一个类的对象实例，并且该类只提供一个其对象实例的方法（静态方法）。
    分类：
        饿汉式（静态常量）
            优点：写法简单，在类装载的时候完成实例化。避免线程同步问题。
            缺点：即使没用到这个类，这个类也会加载，造成内存的浪费。
        饿汉式（静态代码块）
            优点：写法简单，在类装载的时候完成实例化。避免线程同步问题。
            缺点：即使没用到这个类，这个类也会加载，造成内存的浪费。
        懒汉式（线程不安全）——在实际开发不要使用
            优点：取到了懒加载的效果，但是只能在单线程下使用。
            缺点：在一个线程进入if判断语句，还没等得及往下执行，结果另一个线程也进入了if判断语句，会造成多个实例。
        懒汉式（线程安全，同步方法）——实际开发中不推荐使用
            优点：变的更安全了。
            缺点：效率变低了。
        懒汉式（线程安全，同步代码块）
            优点：改进 懒汉式（线程安全，同步方法）,但是不能起到线程同步的作用，和第三种一样。
        双重检查——推荐使用
            优点：延迟加载，效率较高，避免了线程同步。
        静态内部类——推荐使用
            优点：采用类装载的机制保证只有一个实例，避免了线程不安全，实现延迟加载，效率高。
        枚举——推荐使用
            借助JDK1.5
    饿汉式（静态常量）——代码

package com.kun.shejimoshi;
        public class ehanshi1 {
            public static void main(String[] args) {
                Ehanshi ehanshi1= Ehanshi.getInstance();
                Ehanshi ehanshi2=Ehanshi.getInstance();
                System.out.println(ehanshi1==ehanshi2);
            }
        }
        class Ehanshi{
            private Ehanshi() {
            }
            private final static Ehanshi instance=new Ehanshi();
            public static Ehanshi getInstance() {
                return instance;
            }
        }

    饿汉式（静态代码块）——代码
        

package com.kun.shejimoshi;
        public class ehanshi2 {
            public static void main(String[] args) {
                Ehanshi ehanshi1= Ehanshi.getInstance();
                Ehanshi ehanshi2=Ehanshi.getInstance();
                System.out.println(ehanshi1==ehanshi2);
            }
        }
        class Ehanshi{
            private Ehanshi() {
            }
            private static Ehanshi instance;
            static {
                instance=new Ehanshi();
            }
            public static Ehanshi getInstance() {
                return instance;
            }
        }

    懒汉式（线程不安全）——代码
      

 package com.kun.shejimoshi;
        public class lanhanshi {
            public static void main(String[] args) {
                Lanhanshi lanhanshi1=Lanhanshi.getInstance();
                Lanhanshi lanhanshi2=Lanhanshi.getInstance();
                System.out.println(lanhanshi1==lanhanshi2);
            }
        }
        class Lanhanshi{
            private static Lanhanshi instance;
            private Lanhanshi() {
            }
            public static Lanhanshi getInstance() {
                if (instance==null) {
                    instance=new Lanhanshi();
                }
                return instance;
            }
        }

    懒汉式（线程安全，同步方法）加个同步代码块——代码
      

 package com.kun.shejimoshi;
        public class lanhanshi {
            public static void main(String[] args) {
                Lanhanshi lanhanshi1=Lanhanshi.getInstance();
                Lanhanshi lanhanshi2=Lanhanshi.getInstance();
                System.out.println(lanhanshi1==lanhanshi2);
            }
        }
        class Lanhanshi{
            private static Lanhanshi instance;
            private Lanhanshi() {
            }
            public static synchronized Lanhanshi getInstance() {
                if (instance==null) {
                    instance=new Lanhanshi();
                }
                return instance;
            }
        }

    懒汉式（线程安全，同步代码块）——代码
     

   class Lanhanshi{
            private static Lanhanshi instance;
            private Lanhanshi() {
            }
            public static Lanhanshi getInstance() {
                if (instance==null) {
                    synchronized(Lanlanshi.class){
                        instance=new Lanhanshi();
                    }
                }
                return instance;
            }

    双重检查——代码
        

package com.kun.shejimoshi;
        public class shuangchongjiancha {
            public static void main(String[] args) {
                Shuang ehanshi1= Shuang.getInstance();
                Shuang ehanshi2=Shuang.getInstance();
                System.out.println(ehanshi1==ehanshi2);
            }
        }
        class Shuang{
            //volatile是Java虚拟机提供的轻量级的同步机制,保证可见性,防止指令重排
            private static volatile Shuang instance;
            private Shuang() {};
            public static synchronized Shuang getInstance(){
                if (instance==null) {
                    synchronized (Shuang.class) {
                        if(instance==null) {
                            instance =new Shuang();
                        }
                    }
                }
                return instance;
            }
        }

    静态内部类——代码
      

 package com.kun.shejimoshi;
        public class jingtaineibu {
            public static void main(String[] args) {
                Jingtai ehanshi1= Jingtai.getInstance();
                Jingtai ehanshi2=Jingtai.getInstance();
                System.out.println(ehanshi1==ehanshi2);
            }
        }
        class Jingtai{
            private static Jingtai instance;
            private Jingtai() {};
            //静态内部类
            private static class JingtaiInstance{
                private static final Jingtai INSTANCE=new Jingtai();
            }
            public static Jingtai getInstance() {
                return JingtaiInstance.INSTANCE;
            }
        }

    枚举——代码
        

public class meiju {
            public static void main(String[] args) {
                Mei mei1= Mei.INSTANCE;
                Mei mei2= Mei.INSTANCE;
                System.out.println(mei1==mei2);
            }
        }
        enum Mei{
            INSTANCE;
            public void sayOK() {
                System.out.println("ok");
            }
        }