单例模式（Singleton Pattern）

确保一个类在任何情况下都绝对只有一个实例，并且提供一个全局访问点。有时候创建对象时耗时过多或者耗资源过多，但是我们经常用这个对象。我们就可以使用单例模式，并且如果一个工具类存有状态，我们也需要单例，因为如果是多个实例，可能存在数据读取错误的问题，例如配置类，我们就需要单例它，大家去一个地方取就可以了，不需要多个创建。常见的写法

饿汉式单例

懒汉式单例

注册式单例

Threadlocal单例

To explain some terms

High execution efficiency:

classes is created ,When classes are been loading, if we want to get it just getting it and without to create it again

Thread safety:

caused by the calsses that you want are already created,if you do not create it again, it is thread safety,isn't it!

there are no situation that two threads get an one method that you use to creat classes.

Waste of memory：

who can sure that the calsses are uesd certainly？

if you don't use these classes, which means these are occupying memory.

Eager Singleton

public class HungrySingleton {
    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() { }

    private HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

advantages:1.High execution efficiency 2.Thread safety

disadvantages:1.Waste of memory

To solve the problem of Waste of memory. . . .

Lazy Singleton

public class LazySimpleSingleton {
    private static LazySimpleSingleton lazySimpleSingleton;

    private LazySimpleSingleton() { }

    public static LazySimpleSingleton getInstance() {
        if (lazySimpleSingleton != null) {
            lazySimpleSingleton = new LazySimpleSingleton();
        }
        return lazySimpleSingleton;
    }
}

To test

public class ExecuteThread implements Runnable {
    public void run() {
        LazySimpleSingleton lazySimpleSingleton=LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + lazySimpleSingleton);
    }
}
public class LazySimpleSingletonTest {
    public static void main(String[] args) {
        Thread thread=new Thread(new ExecuteThread());
        Thread thread2=new Thread(new ExecuteThread());
        thread.start();
        thread2.start();
    }
}

result:

Actually,Sometimes it produces the same results, sometimes it doesn't,which shows There are problem of security of Thread!

same results:

normal execution sequence

The latter covers the former(2 Threads execute the same code,the former assign the classes but did not return,at this time,the latter began to execute,so latter covers the former.in fact, there are two classes were created )

different results：

2 Threads execute the same code,the former have returned,the the latter returned

tips: the red one is what i said the same code executed
　　　　  if (lazySimpleSingleton != null) {
            lazySimpleSingleton = new LazySimpleSingleton();
        }

advantages: Save memory

disadvantages: Thread unsafe

To solve the problem of Thread of unsafe. . . . (easily,To put a key word of synchronized in front of "static LazySimpleSingleton" like ->(

　　public synchronized static LazySimpleSingleton getInstance())

),but cause a problem that all of the others threads are waiting, the picture below shows that if one thread get a source,which means others can not get the same source,all others will be blocked,in this way,all of others will be waiting and one by one to execute

To solve the problem of performance--------------------------->

public class LazyDoubleCheckSingleton {
    private static LazyDoubleCheckSingleton lazySimpleSingleton;

    private LazyDoubleCheckSingleton() {
    }

    public static LazyDoubleCheckSingleton getInstance() {
        // To check whether we should to create or not,if already the class is create, the left of others do not need to execute code below(solve problem of performance)
        if (lazySimpleSingleton == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                // if two threads enter into, what should we do,so Let's make a judgment here
                if (lazySimpleSingleton == null) {
                    lazySimpleSingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazySimpleSingleton;
    }
}

To explain:

first of all,all threads can be allowed to enter into the method, and if lazySimpleSingleton == null the threads can enter into(solve the problem of performance->do not need to wait), then to use 'synchronized ' to limit problem of Thread unsafe,but if more than one thread enter into and one of these has executed into ending of block of 'if', definitely, the other still will created,so we make a judgement again(resolve the problem of thread unsafe )

but !!! the method will not be elegant enough.. it is hard to read,and produce problem 'Tag and Seek',so we add 'volatile' in front of 'static LazyDoubleCheckSingleton' like

private volatile static LazyDoubleCheckSingleton lazySimpleSingleton;

To solve the problem of not enough elegant--------------------------->

public class LazyStaticInnerClassSingleton {
    public LazyStaticInnerClassSingleton() {
        // what it is essential to creating the class is to use  Constructor to create
        // so if someone wants to use Constructor to create,we just throw Exception to avoid illegal create  
        throw new RuntimeException("forbid to create....");
    }

    public LazyStaticInnerClassSingleton getInstance() {
        return LazyHolder.lazyStaticInnerClassSingleton;
    }

    private static class LazyHolder {
        private static final LazyStaticInnerClassSingleton lazyStaticInnerClassSingleton = new LazyStaticInnerClassSingleton();
    }
}

To explain:

apparently!we use mechanism of class loading,it is well known that during the classess the inner classess are not loaded,when we get the inner class that we want,than the inner class that we want will be load! but all of methods above will be destory by reflect!! what the essence that to use the reflect to create the classess is to use Constructor!so we just need to throw new RuntimeException in Constructor to avoid illegal create , but what i do still not enough decent,who konw the reason why we thrown an exception at the Constructor?

To solve the problem of not enough decent--------------------------->

Register Singleton(container Singleton)

public enum  EnumSingleton {
    INSTANCE;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public   Object data;

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }

}

public class User {
    private String userName;
}

To Test

public class EnumSingletonTest {
    public static void main(String[] args) {
        EnumSingleton instance = EnumSingleton.getInstance();
        instance.setData(new User());
        Class<EnumSingleton> enumSingletonClass = EnumSingleton.class;
        try {
            Constructor<EnumSingleton> constructor = enumSingletonClass.getDeclaredConstructor(String.class,int.class);
            constructor.setAccessible(true);
            EnumSingleton enumSingleton = constructor.newInstance();
            System.out.println(enumSingleton);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

To explain:

the image illustrate that we are not able to create a class with reflection

we find the class of Constructor has wrote ' if the modifier is emum than the class can not be create'

but, why we say that the method must be Thread safety,we still can skim the souce code->(Enum#valueOf),as soon as we create the Enum the 'INSTANCE ' will be put in the container,so Thread safety

so, in some extent , it will produce a new problem of Waste of memory,(put these INSTANCE into container in advance)

To solve the problem of not Waste of memory---------------------------> (we can simluate do it as what IOC does)

public class ContainerSingleton {

    ContainerSingleton() {
    }

    private static Map<String, Object> iocMock = new ConcurrentHashMap<String, Object>();

    public static Object getInstance(String className) {
        Object instance = null;
        if (!iocMock.containsKey(className)) {
            try {
                instance = Class.forName(className).newInstance();
                iocMock.put(className, instance);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return instance;
        }
        return iocMock.get(className);
    }
}
public class Pojo {
    String mock;
}

To test

public class ContainerSingletonTest {
    public static void main(String[] args) {
        Object pojo = ContainerSingleton.getInstance("Pojo");
        Object pojo1 = ContainerSingleton.getInstance("Pojo");
        System.out.println(pojo==pojo1);
    }
}

actually, serialization can destory singleton!!!!!

To solve the problem of destruction the singleton with serialization --------------------------->

public class SerializableSingleton implements Serializable {
    final static SerializableSingleton INSTANCE = new SerializableSingleton();

    private SerializableSingleton() {
    }


    public static SerializableSingleton getInstance() {
        return INSTANCE;
    }

    private Object readResolve() {
        return INSTANCE;
    }
}

To test

public class SerializableSingletonTest {
    public static void main(String[] args) {

        SerializableSingleton s1 = null;

        SerializableSingleton s2 = SerializableSingleton.getInstance();

        FileOutputStream fos = null;
        try {

            fos = new FileOutputStream("D:\growingup\growup\target\SerializableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            // output the file into disk
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            //input the file in  disk into  memory
            FileInputStream fis = new FileInputStream("D:\growingup\growup\target\SerializableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SerializableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

To explain:

first we output the file into disk and input the file in disk into memory again,the result is true(still is a same class)the key is #readResolve,we still skim the souce of code(code java.io.ObjectInputStream#readObject0

after we have read can get that information of there is a judgment if you have a method named readResolve then to get with reflection, otherwise,to create a new instance.so we must be set a method called readResolve,which can help us to resolve problem of serialization with souce of code of java.lang.ClassNotFoundException

The last pattern of singleton i give

Threadlocal pattern of singleton(be ensure globally unique in the same Thread )

public class ThreadLocalSingleton {
    static final ThreadLocal<ThreadLocalSingleton> threadLocalSingletonThreadLocal = new ThreadLocal<ThreadLocalSingleton>() {
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };

    private ThreadLocalSingleton() {
    }

    public static ThreadLocalSingleton getInstance() {
        return threadLocalSingletonThreadLocal.get();
    }

}
public class ExecuteThreadLocal implements  Runnable {
    public void run() {
        ThreadLocalSingleton threadLocalSingleton=ThreadLocalSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + threadLocalSingleton);
    }
}

To test

public class ThreadLocalSingletonTest {
    public static void main(String[] args) {
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());

        Thread thread=new Thread(new ExecuteThreadLocal());
        Thread thread2=new Thread(new ExecuteThreadLocal());
        thread.start();
        thread2.start();
    }
}

To explain

the image above shows there are different threads get different results,but we can get a same instance in same thread，example is main thread(we get the same result in 3 times),we can find reason with resource of code of java.lang.ThreadLocal#get.

Store on a per-thread basis

practical application in souce of code

org.springframework.beans.factory.config.AbstractFactoryBean#getObject

org.apache.ibatis.executor.ErrorContext#instance

Sum up

advantages:

ther is just one instance in memory,which is efficient to diminish Memory overhead

Access is effectively controlled

disasvantages:

there is no interface,so that it is difficult to expand（if we want to extend function,we have to modify original code）