Singleton是一种创建型模式,指某个类采用Singleton模式,则在这个类被创建后,只可能产生一个实例供外部访问,并且提供一个全局的访问点static。
核心知识点如下:
(1) 将采用单例设计模式的类的构造方法私有化(采用private修饰)。
(2) 在其内部产生该类的实例化对象,并将其封装成private static类型。
(3) 定义一个静态方法返回该类的实例。
二、单例模式的实现
方法一:饿汉式(线程安全,但是效率低)
优点:写起来比较简单,而且不存在多线程同步问题,避免了synchronized所造成的性能问题;
缺点:当类SingletonTest被加载的时候,会初始化static的instance,静态变量被创建并分配内存空间,从这以后,这个static的instance对象便一直占着这段内存(即便你还没有用到这个实例),当类被卸载时,静态变量被摧毁,并释放所占有的内存,因此在某些特定条件下会耗费内存。
class Single{
// 构造方法私有化,防止被其他类实例化
private Single(){}
// 懒汉式————类加载的时候自己创建一个实例
static Single single=new Single();
// 静态方法返回类的实例
public static Single getInstance(){
return single;
}
}
//测试类
class TestSingleTon{
public static void main(String[] args){
Single s1=Single.getInstance();
Single s2=Single.getInstance();
// 输出的s1,s2是同一个地址,因为单例模式返回的是同一个实例
System.out.println(s1);
System.out.println(s2);
}
}
方法二:懒汉式(也叫饱汉式)非线程安全
优点:写起来比较简单,当类SingletonTest被加载的时候,静态变量static的instance未被创建并分配内存空间,当getInstance方法第一次被调用时,初始化instance变量,并分配内存,因此在某些特定条件下会节约了内存;
缺点:(线程不安全)并发环境下很可能出现多个SingletonTest实例,致使效率降低。
1、懒汉式基本实现
class Single1{
//私有化构造方法
Single1(){
}
//懒汉式——第一次调用的时候才会创建实例,类加载的时候不会
static Single1 single=null;
public static Single1 getInstance(){
if(single==null){
single=new Single1();
}
return single;
}
}
//测试类
class TestSingle1{
public static void main(String[] args){
Single1 s1=Single1.getInstance();
Single1 s2=Single1.getInstance();
System.out.println(s1);
System.out.println(s2);
}
}
2、懒汉式改进
① 加入同步——同步方法
优点:使用synchronized关键字避免多线程访问时,出现多个SingletonTest实例。
缺点:同步方法频繁调用时,效率略低。
class Single1{
//私有化构造方法
Single1(){
}
//懒汉式——第一次调用的时候才会创建实例,类加载的时候不会
static Single1 single=null;
//同步方法
public static synchronized Single1 getInstance(){
if(single==null){
single=new Single1();
}
return single;
}
}
②双重检查锁定(同步代码块)——线程安全,效率高
class Single1{
//私有化构造方法
Single1(){
}
//懒汉式——第一次调用的时候才会创建实例,类加载的时候不会
static Single1 single=null;
//同步方法
public static Single1 getInstance(){
if(single==null){
synchronized(Single1.class){
//同步代码块(对象未初始化时,使用同步代码块,
//保证多线程访问时对象在第一次创建后,不再重复被创建)
if(single==null){
single=new Single1();
}
}
}
return single;
}
}