今天笔试的时候被问到了单例模式,听了很多次,但是却没有认真看过,所以交了白卷,懒的教训啊!
还有一题比较有趣的题目:System.out.println("ja"+"va"=="java)答案是true,可是我居然脑子抽风答错了,平时不看书的代价
应用场合:有些对象只需要一个就足够了
作用:保证整个应用程序中某个实例有且只有一个
单例模式的特点:
1.只能有一个实例
2.必须自己创建自己的唯一实例
3.必须给所有其他对象提供这一实例
首先单例模式分为饿汉式和懒汉式:
饿汉式
public class Singleton {
//1.将构造方法私有化,不允许外部直接创建对象
private Singleton() {
}
//2.创建类的唯一实例,类加载的时候静态成员也会加载
private static Singleton instance=new Singleton();
//3.提供获取实例的方法,使用public static修饰,使其可以被类调用
public static Singleton getInstance(){
return instance;
}
}
因为类变量和类方法在类加载的时候也会一同加载,所以称其为饿汉式的原因是它把变量提前加载了
懒汉式
public class Singleton2 {
private Singleton2(){
}
private static Singleton2 instance;
public static Singleton2 getInstance(){
if(instance==null){
instance=new Singleton2();
}
return instance;
}
}
称其为懒汉式是因为类加载时变量只是声明了没有创建,调用方法时才创建变量
两者区别:
-饿汉式在类加载完成时单例也已经初始化完成,加载类时比较慢,可是运行时获取对象的速度比较快,它天生就是线程安全的,可以直接用于多线程而不会出问题
-懒汉式当调用getInstance()方法的时候才会去初始化这个单例,加载类时比较快,但运行时获取对象的速度比较慢,它本身是非线程安全的
线程安全:
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的
为什么说懒汉式是非线程安全呢?
假设线程A希望使用SingleTon,调用getInstance()方法,由于是第一次调用,所以检测到instance是null的,于是开始创建实例,可是在这个时候CPU发生时间片切换,线程B也想使用SingleTon并调用getInstance()方法,同样检测到instance为null的--这是在A检测完后切换的,A并没有来得及创建实例--因此B开始创建,当B创建完成后却换到A继续操作,而这时因为A已经检测完所以并不会再检测一次,所以会直接创建对象--这时A,B各拥有了一个SingleTon对象,单例失败!
所以有几个方法解决:
1.加同步锁
public class Singleton2 {
private Singleton2(){
}
private static Singleton2 instance;
public static synchronized Singleton2 getInstance(){
if(instance==null){
instance=new Singleton2();
}
return instance;
}
}
在getInstance()方法上加上同步锁,一个线程必须等另一个线程创建完成后才能使用这个方法,这就保证了单例的唯一性
可是加上了synchronized修饰的同步块运行起来比一般的代码段要慢上几倍的,如果需要调用很多次的话会影响性能,所以要继续优化
2.双重检查锁定:
public class Singleton2 {
private Singleton2(){}
private static Singleton2 instance;
public static Singleton2 getInstance(){
synchronized (Singleton2.class) {
if(instance==null){
instance=new Singleton2();
}
return instance;
}
}
}
首先把同步锁改为加载if语句上,可是每次调用getInstance()时也必须要同步,性能问题依旧没有解决,所以继续修改
public class Singleton2 {
private Singleton2(){}
private static Singleton2 instance;
public static Singleton2 getInstance(){
if(instance==null){
synchronized (Singleton2.class) {
if(instance==null){
instance=new Singleton2();
}
}
}
return instance;
}
}
首先判断instance是否为空,如果为空加锁初始化,如果不为空直接返回instance,避免了每次都同步的性能耗损
3.从源头检查
编译原理:所谓编译，就是把源代码“翻译”成目标代码——大多数是指机器代码——的过程。针对Java，它的目标代码不是本地机器代码，而是虚拟机代码。编译原理里面有一个很重要的内容是编译器优化。所谓编译器优化是指，在不改变原来语义的情况下，通过调整语句顺序，来让程序运行的更快。这个过程成为reorder
下面来想一下，创建一个变量需要哪些步骤呢？一个是申请一块内存，调用构造方法进行初始化操作，另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢？JVM规范并没有规定。那么就存在这么一种情况，JVM是先开辟出一块内存，然后把指针指向这块内存，最后调用构造方法进行初始化
下面考虑这样一种情况:
线程A开始创建SingleTon实例,而线程B此时调用了getInstance()方法,按照上面说的内存模型,此时A已经把instance指向了那块内存,只是还没有调用构造方法,因此B检测到instance不为null,于是直接把instance返回了---此时问题出现了,instance还没有构造完成就被返回了,这就造成错误了
在JDK 5之后，Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前，volatile是个关键字，但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整！因此，只要我们简单的把instance加上volatile关键字就可以了
public class Singleton2 {
private Singleton2(){}
private volatile static Singleton2 instance;
public static Singleton2 getInstance(){
if(instance==null){
synchronized (Singleton2.class) {
if(instance==null){
instance=new Singleton2();
}
}
}
return instance;
}
}
还有一种方法:
静态内部类(推荐)
public class Singleton2 {
private Singleton2(){}
private static class SingletonClassInstance{
private static final Singleton2 instance=new Singleton2();
}
public static Singleton2 getInstance(){
return SingletonClassInstance.instance;
}
}
Singleton2并不是static的,所以不会被初始化,直到调用getInstance()方法时,会首先加载SingletonClassInstance类,这个类有一个static的Singleton2类,所以需要调用Singleton2的构造方法,然后将这个内部类的instance返回给使用者,由于是static的,，所以不会构造多次,由于这个构造是并发的,所以不需要加同步
