2022-02-09 19:37发布
public class Singleton { private static Singleton uniqueInstance;//利用一个静态常量来记录singleton类的唯一实例。 private Singleton() { } public static Singleton getInstance() { if (uniqueInstance == null) {//注意,只有第一次才彻底执行这里的代码 uniqueInstance = new Singleton();//延迟实例化 (lazy instantiaze) } return uniqueInstance;//如果uniqueInstance不是null,就表示之前创建过对象, // 我们就直接跳到return语句 }}
这个版本存在一些问题,当不止一个线程的时候,以两个线程为例,两个线程同时执行到 if (uniqueInstance == null) {}时,因为两个线程里类此时都没有实例化,因此这里还会new两个实例,所以经典模式只适合同步的情况下。
if (uniqueInstance == null) {}
public class Singleton { private static Singleton uniqueInstance;//利用一个静态常量来记录singleton类的唯一实例。 private Singleton() { } public static synchronized Singleton getInstance() { if (uniqueInstance == null) {//注意,只有第一次才彻底执行这里的代码 uniqueInstance = new Singleton();//延迟实例化 (lazy instantiaze) } return uniqueInstance;//如果uniqueInstance不是null,就表示之前创建过对象, // 我们就直接跳到return语句 }}
通过添加synchronized关键字到getInstance方法中,我们强迫每个进入线程中进入该方法的前提是别的线程离开该方法,不会有两个线程同时进入该方法。这种单例模式是线程安全的,不过synchronized会影响程序的性能,只有第一次执行该方法实例化的时候才需要同步,一旦设置好uniqueInstance就不再需要同步这个方法了。因此之后每次调用这个方法,synchronized都是一种累赘。
public class Singleton { private static Singleton uniqueInstance = new Singleton();//利用一个静态常量来记录singleton类的唯一实例。 private Singleton() { } public static Singleton getInstance() { return uniqueInstance;//已经有单例了,直接使用就好了 }}
利用这种写法,JVM在家在这个类时马上创建此唯一的单例。JVM保证任何线程在访问uniqueInstance静态变量时,一定先创建次实例。
public class Singleton { //volatile 关键词确保:当uinqueInstance变量被初始化成Singleton实例时, // 多个线程正确的处理uniqueInstance变量 private volatile static Singleton uniqueInstance;//利用一个静态常量来记录singleton类的唯一实例。 private Singleton() { }//防止多线程出错 public static Singleton getInstance() {//检查实例,如果不存在,进入同步区块。 if (uniqueInstance == null) {//注意,只有第一次才彻底执行这里的代码 synchronized (Singleton.class) { //进入区块后在检查一次,如果仍是null,才创建实例。 if (uniqueInstance == null) { uniqueInstance = new Singleton();//延迟实例化 (lazy instantiaze) } } } return uniqueInstance;//如果uniqueInstance不是null,就表示之前创建过对象, // 我们就直接跳到return语句 }}
想比同步锁单例模式,这种做法可以大大提高性能。volatile 关键词:当uinqueInstance变量被初始化成Singleton实例时,多个线程正确的处理uniqueInstance变量。
public enum Singleton { instance; private xxxxxx instance; Singleton () { instance = new xxxxxx (); } public xxxxxx getInstance() { return instance; }}
上面的类xxxxxx 是我们要应用单例模式的资源,具体可以表现为网络连接,数据库连接,线程池等等。获取资源的方式很简单,只要使用Singleton.instance.getInstance() 即可获得所要实例。在枚举中我们明确了构造方法限制为私有,在我们访问枚举实例时会执行构造方法,同时每个枚举实例都是static final类型的,也就表明只能被实例化一次。在调用构造方法时,我们的单例被实例化。 也就是说,因为enum中的实例被保证只会被实例化一次,所以我们的instance也被保证实例化一次。
xxxxxx
Singleton.instance.getInstance()
1.
懒汉式 懒汉式顾名思义就是实例在用到的时候才去创建,用的时候才去检查有没有实例,如果有则返回,没有则新建。有线程安全和线程不安全两种写法,区别就是synchronized关键字。
2.
饿汉式 饿汉式就是“比较勤”,实例在初始化的时候就已经建好了,不管你有没有用到,都先建好了再说。好处是没有线程安全的问题,坏处是浪费内存空间。
3.
双检锁 双检锁,又叫双重校验锁,综合了懒汉式和饿汉式两者的优缺点整合而成。特点是在synchronized关键字内外都加了一层 if 条件判断,这样既保证了线程安全,又比直接上锁提高了执行效率,还节省了内存空间。
4.
静态内部类 静态内部类的方式效果类似双检锁,但实现更简单。但这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
分别是懒汉式、饿汉式、静态内部类模式、双重锁模式、枚举模式
1、懒汉式
懒汉式顾名思义就是实例在用到的时候才去创建,用的时候才去检查有没有实例,如果有则返回,没有则新建。有线程安全和线程不安全两种写法,区别就是synchronized关键字。
2、饿汉式
饿汉式就是“比较勤”,实例在初始化的时候就已经建好了,不管你有没有用到,都先建好了再说。好处是没有线程安全的问题,坏处是浪费内存空间。
3、双检锁
双检锁,又叫双重校验锁,综合了懒汉式和饿汉式两者的优缺点整合而成。特点是在synchronized关键字内外都加了一层 if 条件判断,这样既保证了线程安全,又比直接上锁提高了执行效率,还节省了内存空间。
4、静态内部类
静态内部类的方式效果类似双检锁,但实现更简单。但这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
5、枚举
枚举的方式是比较少见的一种实现方式,但是看上面的代码实现,却更简洁清晰。并且还自动支持序列化机制,绝对防止多次实例化。
单例模式大致有五种写法,分别为懒汉,恶汉,静态内部类,枚举和双重校验锁。
懒汉写法 public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){}public static SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}}
恶汉写法 public class SingletonDemo {
private static SingletonDemo instance=new SingletonDemo();
private SingletonDemo(){}
public static SingletonDemo getInstance(){
静态类内部加载 public class SingletonDemo {
private static class SingletonHolder{
private SingletonDemo(){
System.out.println("Singleton has loaded");
return SingletonHolder.instance
线程安全的懒汉模式 public class SingletonDemo {
public static synchronized SingletonDemo getInstance(){
双重校验锁法
public class SingletonDemo {
private volatile static SingletonDemo instance;
synchronized (SingletonDemo.class){
}}}
1、懒汉式。顾名思义,很" 懒惰 ",只有实例要用到的时候才创建。记得加上synchronized,不然会有线程安全的问题,比如当有多个线程同时调用getInstance()的时候,就会创建多个实例。
加synchronized,可以用于多线程。
不加synchronized,不可以用于多线程,只能用于单线程,不然会有线程安全问题。
2、饿汉式。顾名思义,很" 饥饿 ",所以第一时间就是去找吃的,也就是第一时间创建实例。
好处:因为没有加synchronized,也就是没有加锁,所以执行效率比懒汉式高。
坏处:类加载时就初始化,浪费内存。
3、双重校验锁,也叫双检锁。这种写法即安全,又能保证在多线程情况下保持高性能,比懒汉式执行效率高,还节省了内存。
线程安全,是因为在synchronized关键字的内外都加了一层 if 条件判断,第一层 if 条件判断中,可能会有多个线程一起进入,所以需要第二层 if 条件判断来再次判断一下,防止生成多个实例。
4、静态内部类,也叫登记式。它的功效和双重校验锁一样,不过实现更简单,推荐使用这种写法。如果我们想创建实例,只需调用getInstance方法即可,这时SingletonHolder类才会被装载。
注意:这种写法只适用于静态域的情况
5、枚举。这种写法很少用,但实现更简洁,而且自动支持序列化机制,绝对防止多次实例化。
利用枚举的特性,让JVM来帮我们保证线程安全和单一实例
在我看来,单例模式可以避免资源空间的浪费,只有一个实例,并且她自己负责创建自己的对象,这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。...
多线程中,单例模式并非线程安全,即便是加上了synchronized关键字
1. 单例模式和多例模式属于对象模式。2. 单例模式的对象在整个系统中只有一份,多例模式可以有多个实例。3. 它们都不对外提供构造方法,即构造方法都为私有。...
单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的类一个类只有一个实例。即一个类只有一个对象实例单例模式的要点有三个;一是某个类只能有一个实例;二是它必须自行创建这个实...
最多设置5个标签!
经典版单例模式
这个版本存在一些问题,当不止一个线程的时候,以两个线程为例,两个线程同时执行到
if (uniqueInstance == null) {}
时,因为两个线程里类此时都没有实例化,因此这里还会new两个实例,所以经典模式只适合同步的情况下。同步锁单例模式
通过添加synchronized关键字到getInstance方法中,我们强迫每个进入线程中进入该方法的前提是别的线程离开该方法,不会有两个线程同时进入该方法。这种单例模式是线程安全的,不过synchronized会影响程序的性能,只有第一次执行该方法实例化的时候才需要同步,一旦设置好uniqueInstance就不再需要同步这个方法了。因此之后每次调用这个方法,synchronized都是一种累赘。
急切式单例模式(直接在静态变量创建单例)
利用这种写法,JVM在家在这个类时马上创建此唯一的单例。JVM保证任何线程在访问uniqueInstance静态变量时,一定先创建次实例。
双重同步锁单例模式
想比同步锁单例模式,这种做法可以大大提高性能。
volatile 关键词:当uinqueInstance变量被初始化成Singleton实例时,多个线程正确的处理uniqueInstance变量。
用枚举实现单例模式
上面的类
xxxxxx
是我们要应用单例模式的资源,具体可以表现为网络连接,数据库连接,线程池等等。获取资源的方式很简单,只要使用Singleton.instance.getInstance()
即可获得所要实例。在枚举中我们明确了构造方法限制为私有,在我们访问枚举实例时会执行构造方法,同时每个枚举实例都是static final类型的,也就表明只能被实例化一次。在调用构造方法时,我们的单例被实例化。 也就是说,因为enum中的实例被保证只会被实例化一次,所以我们的instance也被保证实例化一次。1.
懒汉式 懒汉式顾名思义就是实例在用到的时候才去创建,用的时候才去检查有没有实例,如果有则返回,没有则新建。有线程安全和线程不安全两种写法,区别就是synchronized关键字。
2.
饿汉式 饿汉式就是“比较勤”,实例在初始化的时候就已经建好了,不管你有没有用到,都先建好了再说。好处是没有线程安全的问题,坏处是浪费内存空间。
3.
双检锁 双检锁,又叫双重校验锁,综合了懒汉式和饿汉式两者的优缺点整合而成。特点是在synchronized关键字内外都加了一层 if 条件判断,这样既保证了线程安全,又比直接上锁提高了执行效率,还节省了内存空间。
4.
静态内部类 静态内部类的方式效果类似双检锁,但实现更简单。但这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
分别是懒汉式、饿汉式、静态内部类模式、双重锁模式、枚举模式
1、懒汉式
懒汉式顾名思义就是实例在用到的时候才去创建,用的时候才去检查有没有实例,如果有则返回,没有则新建。有线程安全和线程不安全两种写法,区别就是synchronized关键字。
2、饿汉式
饿汉式就是“比较勤”,实例在初始化的时候就已经建好了,不管你有没有用到,都先建好了再说。好处是没有线程安全的问题,坏处是浪费内存空间。
3、双检锁
双检锁,又叫双重校验锁,综合了懒汉式和饿汉式两者的优缺点整合而成。特点是在synchronized关键字内外都加了一层 if 条件判断,这样既保证了线程安全,又比直接上锁提高了执行效率,还节省了内存空间。
4、静态内部类
静态内部类的方式效果类似双检锁,但实现更简单。但这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
5、枚举
枚举的方式是比较少见的一种实现方式,但是看上面的代码实现,却更简洁清晰。并且还自动支持序列化机制,绝对防止多次实例化。
单例模式大致有五种写法,分别为懒汉,恶汉,静态内部类,枚举和双重校验锁。
懒汉写法 public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){}public static SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}}
恶汉写法 public class SingletonDemo {
private static SingletonDemo instance=new SingletonDemo();
private SingletonDemo(){}
public static SingletonDemo getInstance(){
return instance;
}}
静态类内部加载 public class SingletonDemo {
private static class SingletonHolder{
private static SingletonDemo instance=new SingletonDemo();
}
private SingletonDemo(){
System.out.println("Singleton has loaded");
}
public static SingletonDemo getInstance(){
return SingletonHolder.instance
线程安全的懒汉模式 public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){}
public static synchronized SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}}
双重校验锁法
public class SingletonDemo {
private volatile static SingletonDemo instance;
private SingletonDemo(){
System.out.println("Singleton has loaded");
}
public static SingletonDemo getInstance(){
if(instance==null){
synchronized (SingletonDemo.class){
if(instance==null){
instance=new SingletonDemo();
}}}
return instance;
}}
1、懒汉式。顾名思义,很" 懒惰 ",只有实例要用到的时候才创建。记得加上synchronized,不然会有线程安全的问题,比如当有多个线程同时调用getInstance()的时候,就会创建多个实例。
加synchronized,可以用于多线程。
不加synchronized,不可以用于多线程,只能用于单线程,不然会有线程安全问题。
2、饿汉式。顾名思义,很" 饥饿 ",所以第一时间就是去找吃的,也就是第一时间创建实例。
好处:因为没有加synchronized,也就是没有加锁,所以执行效率比懒汉式高。
坏处:类加载时就初始化,浪费内存。
3、双重校验锁,也叫双检锁。这种写法即安全,又能保证在多线程情况下保持高性能,比懒汉式执行效率高,还节省了内存。
线程安全,是因为在synchronized关键字的内外都加了一层 if 条件判断,第一层 if 条件判断中,可能会有多个线程一起进入,所以需要第二层 if 条件判断来再次判断一下,防止生成多个实例。
4、静态内部类,也叫登记式。它的功效和双重校验锁一样,不过实现更简单,推荐使用这种写法。如果我们想创建实例,只需调用getInstance方法即可,这时SingletonHolder类才会被装载。
注意:这种写法只适用于静态域的情况
5、枚举。这种写法很少用,但实现更简洁,而且自动支持序列化机制,绝对防止多次实例化。
相关问题推荐
利用枚举的特性,让JVM来帮我们保证线程安全和单一实例
在我看来,单例模式可以避免资源空间的浪费,只有一个实例,并且她自己负责创建自己的对象,这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。...
多线程中,单例模式并非线程安全,即便是加上了synchronized关键字
1. 单例模式和多例模式属于对象模式。2. 单例模式的对象在整个系统中只有一份,多例模式可以有多个实例。3. 它们都不对外提供构造方法,即构造方法都为私有。...
单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的类一个类只有一个实例。即一个类只有一个对象实例单例模式的要点有三个;一是某个类只能有一个实例;二是它必须自行创建这个实...