标签：不能 ash 延迟 focus 提高 class new eth 反序列化
单例模式，就是采取一定的方法保证整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)
1.单例模式的八种方式
饿汉式(静态常量)
饿汉式(静态代码块)
懒汉式(线程不安全)
懒汉式(线程安全，同步方法)
懒汉式(线程安全，同步代码快)
双重检查
静态内部类
枚举
首先我们来看一下饿汉式(静态常量)
具体步骤
构造器私有化(防止new)
类的内部创建对象
向外暴露一个静态的公共方法------getInstance()
具体代码实现
package designPattern.singleton;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 13:26
* 饿汉式(静态常量)
*/
public class SingletonTest01 {
public static void main(String[] args) {
// 测试实现
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
class Singleton{
//构造器私有化 外部不能new
private Singleton(){}
//类的内部创建对象实例
private static final Singleton singleton = new Singleton();
//提供一个公有的静态方法，返回实例对象
public static Singleton getInstance(){
return singleton;
}
}
结果显示:
优缺点说明：
优点：这种写法比较简单，就是在类装载的时候完成实例化，避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到LazyLoading的效果，如果从始至终从未使用过这个实例，就会造成内存浪费。
这种方式基于 classloader 机制避免了多线程同步问题，不过instance在类装载时就实例化，在单例模式中大多数是调用getInstance方法，但是导致类装载的原因有很多，因此不能确定有其他的方式（或者其他静态方法）导致类装载，这个时候初始化就没有达到lazyloading的效果。
结论：这种单例模式可用，可能造成内存浪费。
饿汉式(静态代码块)
package designPattern.singleton.type2;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 13:26
* 饿汉式(静态代码块)
*/
public class SingletonTest02{
public static void main(String[] args) {
// 测试实现
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
class Singleton{
//构造器私有化 外部不能new
private Singleton(){}
//类的内部创建对象实例
private static final Singleton singleton;
//在静态代码块中，创建单例对象
static {
singleton = new Singleton();
}
//提供一个公有的静态方法，返回实例对象
public static Singleton getInstance(){
return singleton;
}
}
结果显示：
优缺点说明: 和上面静态常量优缺点一样，只不过就是将类的实例化放在了静态代码块中。
懒汉式(线程不安全)
代码演示：
package designPattern.singleton.type3;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 13:59
* 懒汉式(线程不安全)
*/
public class SingletonTest03 {
public static void main(String[] args) {
// 测试实现
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
class Singleton{
//构造器私有化 外部不能new
private Singleton(){}
private static Singleton singleton;
//提供一个公有的静态方法，当使用该方法时，才去创建instance
public static Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
优缺点说明：
起到了lazy loading的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入if(singleton == null)判断语句块，还未来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可以使用这种方式。
结论：在实际开发中，不要使用这种方式
懒汉式（线程安全，同步方法）
代码演示：
package designPattern.singleton.type4;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 14:25
*/
public class SingletonTest04 {
public static void main(String[] args) {
// 测试实现
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
class Singleton{
//构造器私有化 外部不能new
private Singleton(){}
private static Singleton singleton;
//加入 synchronized 关键字同步处理代码，解决线程安全问题
//提供一个公有的静态方法，当使用该方法时，才去创建instance
public static synchronized Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
优缺点说明：
优点：解决了线程安全问题。
结论：实际开发中，不推荐使用这种方式。
双重检查：
代码演示：
package designPattern.singleton.type6;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 14:31
*/
public class SingletonTest06 {
public static void main(String[] args) {
// 测试实现
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
class Singleton{
//构造器私有化 外部不能new
private Singleton(){}
//类的声明变量加上 volatile 关键字
//volatile让变量每次在使用的时候，都从主存中取。
//volatile变量对于每次使用，线程都能得到当前volatile变量的最新值。
private static volatile Singleton singleton;
//提供一个公有的静态方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
//同时保证了效率
public static Singleton getInstance(){
if(singleton == null){
synchronized (Singleton.class){
if(singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
}
优缺点说明：
Double-Check概念是多线程开发中经常使用的，如代码中所示，我们进行了两次 if(singleton == null) 检查，这样就保证了线程安全了。
线程安全，延迟加载，效率较高。
结论：在实际开发中，推荐使用这种方式。
静态内部类：
代码演示：
package designPattern.singleton.type7;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 15:12
*/
public class SingletonTest07 {
public static void main(String[] args) {
// 测试实现
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
//静态内部类完成 推荐使用
class Singleton{
//构造器私有化 外部不能new
private Singleton(){}
//写一个静态内部类，该类中有一个静态属性 INSTANCE
private static class SingletonInstance{
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法，SingletonInstance.INSTANCE
public static Singleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
为什么是线程安全的
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>
优缺点说明：
这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在Singleton类被装载的时候并不会立即实例化，而是在需要实例化的时候，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保障了线程的安全，在类进行初始化时，别的线程是无法进入的。
避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。
结论：推荐使用。
枚举
代码演示：
package designPattern.singleton.type8;
/**
* @author : 雪飞oubai
* @date : 2020/3/15 15:31
*/
public class SingletonTest08 {
public static void main(String[] args) {
Singleton singleton1 = Singleton.INSTANCE;
Singleton singleton2 = Singleton.INSTANCE;
System.out.println(singleton1 == singleton2);
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
//使用枚举，可以实现单例
enum Singleton{
INSTANCE; //属性
public void sayOK(){
System.out.println("ok");
}
}
优缺点说明：
这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建对象。
结论：推荐使用
单例模式在 JDK 中的使用 举个栗子：
* @author unascribed
* @see java.lang.Runtime#getRuntime()
* @since JDK1.0
*/
public class Runtime {
private static Runtime currentRuntime = new Runtime();
/**
* Returns the runtime object associated with the current Java application.
* Most of the methods of class <code>Runtime</code> are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the <code>Runtime</code> object associated with the current
* Java application.
*/
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don‘t let anyone else instantiate this class */
private Runtime() {}
单例模式保证了系统中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建和销毁的对象，使用单例模式可用提高系统性能。
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
单例模式的使用场景：需要频繁创建和销毁的对象、创建对象时耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）
标签：不能 ash 延迟 focus 提高 class new eth 反序列化
原文地址：https://www.cnblogs.com/lililixuefei/p/13185757.html
