单例模式

单例模式: 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

使用场景： 1. 系统中读取xml 或者 properties 的时候,可以先写一个文件配置的类，然后用流方法读取配置文件信息, 存在问题： 1.多次去存取配置文件，严重浪费内存。

解决思路： 1.类的构造器是公用的，可以在外部创建多个实例，可以改为private 在类内部自己创建自己的实例。 然后再创建一个公用的入口。

 
单例模式实例代码： 
一，懒汉式： package sigle; 
/**
* 懒汉式的单例实现方式
* Created with IntelliJ IDEA.
* User: hp
* Date: 13-9-15
* Time: 下午9:53
*/
public class SlobSingleton {

 

/**
* 创建一个变量来存储创建好的类实例
*/
private static SlobSingleton slobSingleton = null;

 

/**
* 私有的构造函数,可以在内部控制创建实例的数目
*/
private SlobSingleton(){

 

}

 

public static synchronized SlobSingleton getSlobSingleton(){

 

if (slobSingleton == null ){
slobSingleton = new SlobSingleton();
}
return slobSingleton;
}

 

public static void main(String[] args) {
SlobSingleton singleton1 = SlobSingleton.getSlobSingleton();
SlobSingleton singleton2 = SlobSingleton.getSlobSingleton();
System.out.println(singleton1);
System.out.println(singleton2);
}
}

 

 

二，饿汉式：
package sigle;

 

/** 饿汗单例模式的实现
* Created with IntelliJ IDEA.
* User: hp
* Date: 13-9-15
* Time: 下午10:07
*/
public class HungrySingleton {

 

/**
* 定义一个变量来存储创建好的实例变量,这里直接创建类变量，只能创建一次
*/
private static HungrySingleton hungrySingleton = new HungrySingleton();

 

private HungrySingleton(){

 

}
public static HungrySingleton getHungrySingleton(){
return hungrySingleton;
}

 

public static void main(String[] args) {
HungrySingleton hungrySingleton1 = HungrySingleton.getHungrySingleton();
HungrySingleton hungrySingleton2 = HungrySingleton.getHungrySingleton();
System.out.println(hungrySingleton2);
System.out.println(hungrySingleton1);

 

}
}

 

认识单例模式：

 

1.线程安全,不加同步的懒汉式是线程不安全的

 

两个线程A,B ,线程A 刚创建了一个类实例，然后B线程就通过了null 判断进来了，这样就并发了，创建了两个类实例。

 

如何实现懒汉式的线程安全呢？
只要加上synchronized 即可。

 

eg：public static synchronied SlobSingle getSlobInstance(){
}

 

但是这样存在一个问题, 会降低性能。每次都要判断。
可以考虑用双重检查加锁

 

eg:

 

 

package sigle;

 

/**
* 懒汉式的线程安全实现
* Created with IntelliJ IDEA.
* User: hp
* Date: 13-9-15
* Time: 下午11:23
*/
public class SafeSingleton {

 

private static volatile SafeSingleton safeSingleton = null;

 

private SafeSingleton(){

 

}

 

public static SafeSingleton getSafeSingleton(){

 

if ( null == safeSingleton ){
synchronized(SafeSingleton.class){
if (null == safeSingleton){
return new SafeSingleton();
}
}
}

 

return safeSingleton;
}
}

 

2.饿汉式是线程安全的。因为虚拟机保证只会装载一次。在装载的时候是不会发生并发的。