设计模式：单例模式，懒汉与饿汉（转）工厂模式

Posted 2021-01-13 hplsharenote

在某些情况下，有些对象只需要一个就可以了，换句话说，每个类只需要一个实例。比如，一台计算机连接多台打印机，但这个计算机上打印程序只能有一个，这里就需要单例模式来避免打印机左右同时输入到打印机中。、

单例模式的作用就是保证整个应用程序的生命周期中，任何一个时刻，单例类的实例都只存在一个。单例模式主要有三个特点：

1. 单例类只能有一个实例

2. 单例类必须创建自己唯一的实例。

3. 单例类必须为其他对象提供这一实例。

那么如何实现满足上述条件的单例类呢？答案是：

1. 私有构造方法。

2. 内部创建静态对象。

3. 提供静态方法返回该静态对象。

 

单例设计模式主要有两种实现方法：饿汉式和懒汉式。

 

1. 饿汉式单例：在定义开始，便实例化自己。

 

public class Single0 {
private Single0() {
//私有构造方法
}
private static Single0 s=new Single0();//内部创建静态方法，实例化
public static Single0 getsingle() {
return s;//提供静态方法，返回对象
}
}

2. 懒汉式单例：在第一次调用时实例化自己。

 

class Single1{
private Single1() {
//私有构造方法
}
public static Single1 s=null;
public static Single1 getsingle() {
s=new Single1();//实例化
return s;
}
}

那饿汉式和懒汉式分别有什么区别呢？

1. 线程安全：

饿汉式天生线程安全，可以直接用于多线程而不会出现问题。

懒汉式本身非线程安全，需要人为实现线程安全。

2. 资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，造成内存泄漏，但相应的，在第一次调用时速度也会更快。

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

 

为了保证懒汉式的线程安全，通常有三种方法：

1. 全局访问点加同步。

由于synchronized是锁方法, 当两个线程都要进入getsingle()时, 只有一个能进入, 并创建出实例, 然后另外一个进入后, 判断 s不为null, 然后直接得到s。 这种做法是没有错误的. 但是由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之，不管对象有没有被创建，其余线程都只能等待这个方法的锁。

class Single1{
private Single1() {
//私有构造方法
}
public static Single1 s=null;
public static synchronized Single1 getsingle() {
s=new Single1();//实例化
return s;
}
}

2. 双重检查锁定。

由于上述都是在等待同步方法的锁，很容易想到把synchronized放在方法里面，这样可以避免方法的阻塞。

 

class Single2{
private Single2() {
//私有构造方法
}
public static Single2 s=null;
public static Single2 getsingle() {
if(s==null) {
synchronized(Single2.class) {
s=new Single2();//实例化
}
}
return s;
}
}

这种写法看似没有问题, 其实却有一个很大的隐患, 在于：如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null，所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。
所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:

 

class Single3{
private Single3() {
//私有构造方法
}
public static Single3 s=null;
public static Single3 getsingle() {
if(s==null) {
synchronized(Single3.class) {
if(s==null) {
s=new Single3();//实例化
}
}
}
return s;
}
}

3. 静态内部类：既实现了线程安全，又避免了同步带来的性能影响。
---------------------
作者：model1220
来源：CSDN
原文：https://blog.csdn.net/sinat_33057149/article/details/78218146?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文链接！

 

 

手写工厂模式：

interface IFactory{
public IProduct createProduct();}
Class Factory implements IFactory{
public IProduct createProduct(){return new Product();}}
Public class client{
Public Static void main (String [] args){IFactory factory=new Factory();
IProduct product=factory.createProduct();
product.ProductMethod();}}
---------------------
作者：hopeplus
来源：CSDN
原文：https://blog.csdn.net/hope900/article/details/78647466?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文链接！