饿汉式和懒汉式的区别 饿汉子的懒媳妇

单例模式中下面类的自我的依赖关系是怎么添加的（Powerdesigner）

这段代码简单明了，而且使用了懒加载模式，但是却存在致命的问题。当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。也就是说在多线程下不能正常工作。

ja单例设计模式：保证对象的设计模式

饿汉式和懒汉式的区别 饿汉子的懒媳妇

饿汉式和懒汉式的区别 饿汉子的懒媳妇

实现步骤：

1、私有化构造函数

2、在当前这个类中创建这个类的对象并且私有化

3、向外界提供一个访问当前类对象的方法（必须是静态方法）

1、饿汉式：

public class Student{

private Student(){//步、私有化构造函数

}private final static Student st=newStudent();//第二步、在当前这个类中创建这个类的对象并且私有化

public statipublic class Singleton {c Student getInstance(){//第三步、向外界提供一个访问当前类对象的方法（必须是静态方法）

return st;

2、懒汉式：

public class Student2{

private Student2(){//步、私有化构造函数

}private final static Student2 st=null;//第二步、在当前这个类中创建这个类的对象并且私有化

public static Student2 getInstance(){//第三步、向外界提供一个访问当前类对象的方法（必须是静态方法）

if(st==null){

st=new Student2();

}return st;

Ja单例模式是什么意思？

B.错误

Ja单例模式是确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例，在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例的模式；

13

Ja单例模式分三种：懒汉式单例、饿汉式单例、登记式单例。 （1）Ja单例模式有以下特点：单例类只能有一个实例；单例类必须自己创建自己的实例；单例类必须给所有其他对象提供这一实例。

（2）Ja单例模式的应用范围：每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中，每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。

ja之单例设计模式

static

设计模式 解决某一类问题最行之有效的方法 （ja中有 种通用设计模式）单例设计模式 解决一个类在内存中只存在一个对象 单例设计模式有两种方式 ）饿汉式先初始化对象 当类一进内存就创建好对象 ）懒汉式对象是方法被调用时才初始化 也叫延时加载 类进内存时 对象还没有存在 只有通过方法调用时 才建立对象 单例设计模式 是想要保证对象的 ）为了避免其他程序过多建立该类对象 先禁止其他程序建立该类对象 ）还为了让其他程序可以访问到该类对象 只好在本类中自定义一个对象 ）为了方便其他程序对自定义对象的访问 可以对外其他一些访问方式 利用这三步进行代码实现 ）将构造函数私有化 ）在类中创建一个本类对象 ）提供一个方法可以获取到该对象提示 在单例设计模式中 事物该怎么描述还怎么描述 当需要将该事物的对象保证在内存中时 加上以上三步即可 代码说明 // ）饿汉式[ja]class Single{private int num;public void setNum（int num）{this num = num;}public int getNum（）{return num;}//将构造函数私有化private Single（）{}//在类中创建一个本类对象 因为构造函数被私有化 该类不能创建对象 想在外部访问 所以将其静态private static Single s = new Single（） //提供一个方法可以获取到该对象 不能创建对象 所以将方法静态 可以通过 （类名 方法名）的形式进行访问public static Single getInstance（）{return s;}}class SingleDemo{public static void main（String[] args）{//单例的构造函数被静态后不能创建对象 保证对象的 所以通过 （类名 方法名）的形式进行访问Single s = Single getInstance（） Single s = Single getInstance（） s setNum（ ） System out println（s getNum（）） //结果 因为Single单例里面对对象和方法进行了静态 数据共享 所以s 的值}}

instance = new Singleton();

lishixinzhi/Article/program/Ja/hx/201311/26060

单例模式的实现方式

几种常见的方法：

饿汉式：这种实现方式在类加载时就完成了实例化，因此也被称为“提前实例化”或“饿汉式”。这种实现方式的好处是，一旦类加载完成，实例就被创建并存储在内存中，后续的请求都会直接返回这个实例，不需要再进行额外的实例化作。 ```python class Singleton: 代码示例 ``` 在上面的代码中，Singleton类的静态变量__instance初始化为None。每次尝试创建新实例时都会检查__instance是否已经存在实例。

懒汉式：这种实现方式在需要使用单例时才创建实例。这种实现方式的缺点是存在线程安全问题，因为多个线程可能同时尝试创建实例。为了解决这个问题，我们可以使用synchronized关键字或者使用线程局部变量来实现线程安全。 ```python class Singleton: 代码示例 ``` 在上面的代码中，我们使用了synchronized关键字来确保只有一个线程如果单例类实现了序列化接口Serializable, 就可以通过反序列化破坏单例，所以我们可以不实现序列化接口,如果非得实现序列化接口，可以重写反序列化方法readResolve(), 反序列化时直接返回相关单例对象。可以创建实例。

静态内部类：这是另一种常见的单例模式实现方式。通过将单例对象封装在一个静态内部类中，我们可以确保只有一个实例被创建。这种方式的好处是简单易用，并且可以轻松地支持多线程环境。 ```python class SingB.错误leton: 代码示例 ``` 在上面的代码中，我们使用了一个静态内部类来封装单例对象。

Android 深入理解单例模式

public static Singleton getSingleton () {

本文主要记录使用单例模式的几种形式，并分析各自的优缺点。使用单例模式可以避免重复创建对象，以此来节省开销，首先了解一下单例模式的四大原则：

常用的单例模式有：饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐个解释这些模式的区别。

关于 volatile 修饰符，又是一个内容，需要理解：

参考（有例子，比较好理解）： ，

静态内部类单例模式的优点：

那么有人会问了，如果有多个线程同时访问 getInstance() 方法，会多次初始化类，然后创建多个对象吗？是不会的，这我们需要了解一下类的加载机制：

虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。

所以如果一个类的()方法中有耗时很长的作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但线程唤醒之后不会再次进入()方法。因为在同一个加载器下，一个类只会初始化一次。)

所以静态内部类单例模式不仅能保证线程的安全性、实例的性、还延迟了单例的实例化。

但是静态内部类单例模式也有一个 缺点 ，就是无法传递参数。因为它是通过静态内部类的形式去创建单例的，所以外部就无法传递参数进去。

枚举单例模式占用的内存是静态变量的两倍，所以一般都不使用enum来实现单例。

单例有饿汉模式、懒汉12模式、双重锁懒汉模式、静态内部类模式、枚举模式这几种形式。

饿汉模式在初始化类时就创建了对象，容易造成资源浪费；懒汉模式在多线程环境下有风险；枚举模式占用内存过高。这三种模式都有明显的弊端，所以一般不去采用。

双重锁懒汉模式使用了 volatile 修饰符，在性能上会一点点；静态内部类模式无法传递参数。但是这两种方式都能保证实例的性，线程的安全性，也不会造成资源的浪费。所以我们在使用单例模式时，可以在这两种方式中酌情选择。

参考文章：

智慧树知到《设计模式与软件体系结构》见面课

1、任何设计模式均是为了解决特定场景的耦合问题，以达到对修改关闭，对扩展开放的效果。命令模式主要是解决请求者与实现者之间的耦合关系。

智慧树知到《设计模式与软件体系结构》见面课

1、工厂设计模式可以分为：简单工厂方法，工厂方法模式和抽象工厂模式。

A.正确

2、创建型软件设计模式分为：简单工厂方法模式、工厂方法模式、抽象工厂模式、生成器模式、单例模式和原型模式。

A.正确

A.正确

4、单例模式分为饿汉式和懒汉式两种类型。

A.正确

5、生成器模式为了使构建复杂对象的过程和它的部件解耦，软件设计用一个类单独封装一个构造对象的过程，该类为（Director类）。

A.正确

6、在原型设计模式里运用技术来快速构建对象，而分类深与浅两种类型。

A.正确

A.正确

2、命令模式将请求封装成对象，形成命令，以便统一控制。使得不同的请求，如日志、队列等来参数化其他对象。

A.正确

A.老板

B.厨师

C.服务员

D.菜单

正确：厨师#服务员#菜单

4、命令模式的优点是（ ）。

A.降低了系统耦合度

B.新的命令可以很容易添加到系统中去

C.使用命令模式可能会导致某些系统有过多的具体命令类

D.使用命令模式可以快速创建对象

正确//注意，这里没有final：降低了系统耦合度#新的命令可以很容易添加到系统中去

5、命令模式的缺点是（ ）。

A.降低了系统耦合度

B.新的命令可以很容易添加到系统中去

C.使用命令模式可能会导致某些系统有过多的具体命令类

D.使用命令模式可以快速创建对象

正确：使用命令模式可能会导致某些系统有过多的具体命令类

1、装饰器模式又叫包装模式，装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

A.正确

2、装饰器模式以对客户透明的方式动态地给一个对象附加上更多的。

A.正确

3、使用继承方法，可重写父类中的方法以增强父类的与功能，但使用继承会破坏对象的封装性及浪费继承位，不建议使用。

A.正确

4、 在Ja JDK中大量运用了装饰器模式，如JDK经常使用的Reader抽象类，CharArrayReader类、InputStreamReader类、BufferedReader类等。

A.正确

5、装饰器模式的类图中具有（ ）。

类名 对象名=类名.方法名() [如：Runtime time=Runtime.getRuntim

2.懒汉式单例类

getRunTime()是因为在底层的RunTime中使用的是单例模型获取RunTime对象的额，必须调用这个方法才可以得到RunTime对象，RunTime的构造方法私有化了

B.错误

创建了一个类的对象，并调用这个对象的方法

单例模式的饿汉模式为啥是线程安全的

线程安全-百度百科

本词条由“科普”科学百科词条编写与应用工作项目 审核 。

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

我觉的这个定义是比较准确的。

我的理解是这样的，线程之所以产生安全问题是对原来正确数据造成改变污染。对于单例懒汉模式下，单例类原本在多线程的情况下应该只会产生一个对象，实际上会出现产生多个对象，数据出现错误，所以说线程是不安全的；然而对与单例饿汉情况，多线程在实例化单例类时并不会出现多的对象的情况，数据正确，所以并未出现线程安全。

对于你将的多个对像............的问题：准确的是说，多个线程访问共享资源会出现线程安全，当然这也是包含在数据被污染的大内。

我结合该问题写的文章，多多支持：

哦哦,忽略我刚才的评论,你的问题是在 不是同一个对象是不是就不安全了 . 这个问题也不尽然啊,要具体的看这个对象干啥事.如果你刚才说的那个计时器,如果加上单例模式,就安全了.如果不加上单例模式,不安全的原因是 :

serv3、创建型软件设计模式的目标是将一个系统与其对象的创建、组合、表示分离开来，该模式的主要任务是为客户程序创建对象，而不是由客户程序直接初始化对象。count ++

这语句实际上是执行了三两种实现形式：个步骤 ，

1 从内存中读取 servcount 的值,

2 servcount 加上1

3 将servcount 保存到内存.

如果个线程还没有把加一之后的 servcount 值保存到内存,这时候第二个线程进来,读取的值,也是线程读取的值,这时候就出问题.

如果这个方法,能够用syncronized修饰,那么无论几个线程进来,都没有问题了.就没有必要进行单例了.所以你的处理办法是

syncronized{

servcount ++ ;

}而不是用单例.

结论 : 单例能够保证获取的类的实例只有一个,这时候是安全的.

是否选择单例,跟具体业务有关系

不是单例模式,也不一定就是不线程安全的(这是废话)

单例模式之饿汉式，由于是在类加载时加创建了对象，且类加载只会加载一次(不考虑特殊极端情况)，适合全局的对象，比如MyBatis中的SqlSessionFactory对象。

在多线程情况下，我们使用锁来保证线程安全。就拿synchronized来说，我们通常会对一个的对象进行上锁，而单例模式正好是的，保证只有一个线程会抢占到锁，同一时间只会有一个线程去修改共享数据，所以是线程安全的。

项目实战—那些年常用的单例模式

56

饿汉式单例：类初始化时将单例对象加载到JVM中。

class

懒汉式单例：并发写时，存在线程安全问题。进化版： 双重检查锁模式 。

volatile关键字详见— Volatile可见性原理

除枚举方式外, 其他方法都会通过反射的方式破坏单例,反射是通过调用构造方法生成新的对象，所以如果我们想要阻止单例破坏，可以在构造方法中进行判断，若已有实例, 则阻止生成新的实例，解决办法如下:

枚举类来实现单例模式

jvm虚拟机加载类，是把类的属性和方法全加载了吗？

正确：A

我来回答一下你的问题:

1、类的加载时机：当这个类被实例化的时候如：new A();或者执行这个类里面的static(静态方法时)如：main方法，这个类才会被加载。你说的30个类它注重到lazy不会一下被加载，只有出现以上2种情况的时候才会加载。当然ja.lang这个包里的类会在ja虚拟机启动的时候加载(加载是将编译后的.class文件加载)。

2、类里面的属性分为静态的属性，和非静态的属性。

2.1 静态的属性只会加载一次，次实例化的时候分配空间，以后再实例化这个类的时候不会再分配内存空间。这个静态属性属于这个类的，供这个类的所有实例共享。

2.2非静态的属性会在每次实例化的时候就会分配内存空间，如一个类被实例化10次，那么这个属性会分配10次内存空间，并且它只属于当前自己实例，不属于其他的实例对象。

2.3至于方法就是方法被调用的时候才会执行，你说的加载其实在实例化这个类的时候这个方法就被以.class文件加载到虚拟机里了。

3、程序的开始一般是以main方法开始执行的时候就叫程序的开始。

希望我的回答对你有帮助。^_^

如何正确地写出单例模式

一般来说种比较安全。进入讨论组讨论。

当被问到要实现一个单例模式时，很多人的反应是写出如下的代码，包括教科书上也是这样教我们的。

34

78

0

11

private static Singleton instance;

private Singleton (){}

public static Singleton getInstance () {

if (instance == null ) {

}return instance;

懒汉式，线程安return "Hello, I am RegSingleton.";全

为了解决上面的问题，最简单的方法是将整个 getInstance() 方法设为同步（synchronized）。

34

public static synchronized Singleton getInstance () {

if (instance == null ) {

}return instance;

}虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步作只需要在次调用时才被需要，即次创建单例实例对象时。这就引出了双重检验锁。

双重检验锁

双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null ，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

34

78

0

if (instance == null ) { //Single Checked

synchronized (Singleton.class) {

if (instance == null ) { //Double Checked

}return instance ;

}这段代码看起来很完美，很可惜，它是有问题。主要在于 instance = new Singleton() 这句，这并非是一个原子作，事实上在 JVM 中这句话大概做了下面 3 件事情。

给 instance 分配内存

调用 Singleton 的构造函数来初始化成员变量

将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

我们只需要将 instance 变量声明成 volatile 就可以了。

34

78

0

11

14

15

16

private volatile static Singleton instance; //声明成 volatile

private Singleton (){}

if (instance == null ) {

synchronized (Singleton.class) {

if (instance == null ) {

}return instance;

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值作后面会有一个内存屏障（生成的汇编代码上），读作不会被重排序到内存屏障之前。比如上面的例子，取作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写作都先行发生于后面对这个变量的读作（这里的“后面”是时间上的先后顺序）。

但是特别注意在 Ja 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Ja 5 以前的 JMM （Ja 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Ja 5 中才得以修复，所以在这之后才可以放心使用 volatile。

相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的办法。

饿汉式 static final field

这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。

34

78

0

//类加载时就初始化

private static final Singleton instance = new Singleton();

private Singleton (){}

public static Singleton getInstance (){

return instance;

这种写法如果完美的话，就没必要在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式（lazy initialization），单例会在加载类后一开始就被初始化，即使客户端没有调用 getInstance()方法。饿汉式的创建方式在一些场景中将无法使用：譬如 Singleton 实例的创建是依赖参数或者配置文件的，在 getInstance() 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。

静态内部类 static nested class

我比较倾向于使用静态内部类的方法，这种方法也是《Effective Ja》上所的。

34

78

9public class Singleton {

private static class SingletonHolder {

private static final Singleton INSTANCE = new Singleton();

}private Singleton (){}

public static final Singleton getInstance () {

return SingletonHolder.INSTANCE;

这种写法仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

枚举 Enum

用枚举写单例实在太简单了！这也是它的优点。下面这段代码就是声明枚举实例的通常做法。

ublic enum EasySingleton{

INSTANCE;

}我们可以通过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。创建枚举默认就是线程安全的，所以不需要担心double checked locking，而且还能防止反序列化导致重新创建新的对象。但是还是很少看到有人这样写，可能是因为不太熟悉吧。

总结

一般来说，单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现，文章开头给出的种方法不算正确的写法