JDK设计模式之—单例模式和static关键字

首先了解static 关键字

static声明的方法是静态方法，static声明的成员变量为静态成员变量。对于该类的所有对象来说，static的成员变量和static只有一份存储空间

即使没有创建该类的对象(实列)，也可以使用该类static的成员变量和static方法。

　　static所修饰的成员变量和静态代码块当虚拟机对该类初始化的时候就会被创建，也就是即使没有创建这个类的实列，java虚拟机也能根据类名在运行时数据区的方法内找到他们。(也就是说类的初始化和创建类的实列并不是一回事)

静态方法中不能使用this关键字

　　这个也很好理解。当一个对象创建好之后，java虚拟机就会给它分配一个引用自身的指针:this。也就是说 this是当前对象的引用。红字部分说了是当前对象的引用，而执行static方法的时候对象的实列可能还没被创建，所static方法中不能引用this关键字。同理不止是this关键字，static方法中不可访问任何非static的成员变量。同理非static的成员变量在类被初始化的时候才会被创建

为什么作为程序入口的main方法是static方法

　　把main()方法定义成static的静态方法，java虚拟机只要加载了main方法所属的类，就能执行main方法。而无需先创建这个类的实列

试想:如果main方法不是static的时候运行main方法需要创建该类的实列，类的main是创建实列的入口。

补充：不管是静态方法，还是普通方法他的字节码都位于方法区内。

为什么 static 成员变量要和final一起用 public static final int xxx ;

　　因为static关键字修饰的成员变量，程序中只有一份。多个线程同时操作的时候会产生并发的bug。final关键字修饰的变量不能被更改

　　所以static final连用可以防止静态变量并发的bug。

　　static 也可有ThreadLocal连用同样可以防止线程并发的bug

利用static关键字实现单例模式(懒汉式)

　　在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。

　　2.1：类的构造函数定义为private的，保证其他类不能实例化此类，

　　2.2：然后提供了一个静态实例static XX xx= new XX（）并返回给调用者。

　　它的好处是只在类初始化的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。

　　缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。

public class Singleton{
    //类被搜索加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。
    private static Singleton instance = new Singleton();//static的属性，是在类定义被JVM所加载时   就初始化完毕的，是类的所有实例共有的
    private Singleton(){//私有的构造方法
        
    }
    public static Singleton getInstance(){
        return instance;
    }
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1==s2);
    }
}

View Code

以下补充类的初始化过程，了解一下类的初始化和创建类的实列区别

饿汉式单例模式

当程序第一次访问单件模式实例时才进行创建。

public class Singleton{
    private static Singleton instance ;
    private Singleton(){
        
    }
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1==s2);
    }
    
}

View Code

注意synchronized关键字的使用，防止因为并发导致创建多个对象

反序列化打破单例模式

反序列化会创建一个对象，打破了单例只有一个实列的约定。

public class Singleton implements Serializable{
    private static final long serialVersionUID = 1L;
    
    private static Singleton instance ;
    private Singleton(){
        
    }
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }
    
    public static void main(String[] args) throws Exception {
        Singleton s1 = Singleton.getInstance();

        ByteArrayOutputStream buf = new ByteArrayOutputStream();
        ObjectOutputStream o = new ObjectOutputStream(buf);
        o.writeObject(s1);
        
        ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream(buf.toByteArray()));
        Singleton s2 = (Singleton) in.readObject();
        System.out.println(s1==s2);
        
    }
    
}

View Code

解决办法: 在类中增加readResolve()方法

private Object readResolve(){
        return instance;
    }

如果一个类提供了readResolve()方法，重新指定反序列化的对象。

那么在执行反序列化操作时，先按照默认的方式或者用户自定义的方式进行反序列化，最后调用readResolve()方法，该方法返回的对象为反序列化的最终结果。