目录
1. 设计模式
2. 单例模式 -- 饿汉模式
3. 单例模式 -- 懒汉模式
4. 单例模式(懒汉模式-多线程)
1. 设计模式
什么是设计模式?
设计模式好比象棋中的 "棋谱". 红方当头炮, 黑方马来跳. 针对红方的一些走法, 黑方应招的时候有一些固定的套路. 按照套路来走局势就不会吃亏.
软件开发中也有很多常见的 "问题场景". 针对这些问题场景, 大佬们总结出了一些固定的套路. 按照这个套路来实现代码, 也不会吃亏.
单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例.在特定场景下只被允许创建一个对象,比如在中国实行的是一夫一妻制.
2. 单例模式 -- 饿汉模式
class MySingleton {
//static 该属性属于类的属性
//JVM 每个类对象只有唯一一份,类对象里的这个成员自然也就是唯一一份.
//instance是唯一实例
private static MySingleton instance = new MySingleton();
private MySingleton(){
//禁止外部创建新的实例
//将构造方法设置为private
};
public static MySingleton getInstance() {
return instance;
}
public static void setInstance(MySingleton instance) {
MySingleton.instance = instance;
}
}
public class Singleton1 {
public static void main(String[] args) {
//1.此时s1 和 s2 是同一个对象
MySingleton s1 = MySingleton.getInstance();
MySingleton s2 = MySingleton.getInstance();
System.out.println(s1 == s2);
//2.我们要禁止这个new操作,把该类的构造方法用private修饰
//Singleton.MySingleton s3 = new Singleton.MySingleton();
}
}上述代码就是单例模式中的饿汉模式
1.加载类的同时,创建实例对象.
2.同时将构造方法变为私有
理解:我吃完饭,我就把碗洗了
3. 单例模式 -- 懒汉模式
class MySingletonLazy{
private static MySingletonLazy instance = null;
public static MySingletonLazy getInstance(){
if (instance == null){
instance = new MySingletonLazy();
}
return instance;
}
private MySingletonLazy(){
}
}上述代码就是单例模式中的懒汉模式
1.加载类的时候,没有创建实例对象.而是写成一个静态方法,当需要创建对象的时候调用静态方法,创建对象.
2.同时将构造方法变为私有
理解:吃完饭,没有把碗洗了,而是我什么时候用,什么时候洗碗
4. 单例模式(懒汉模式-多线程)
思考:
上述两种模式,加入多线程是否是线程安全的?
答案: 饿汉模式安全,懒汉模式不安全
在多线程中，懒汉模式可能无法保证创建对象的唯一性。
如何解决由于懒汉模式(多线程)引起的线程的不安全呢?
答案: 加锁 保证判定操作和new操作是原子性的。
class MySingletonLazy2{
volatile private static MySingletonLazy2 instance = null;
public static MySingletonLazy2 getInstance(){
synchronized (MySingletonLazy.class){
//保证原子性
if (instance == null){
instance = new MySingletonLazy2();
}
}
return instance;
}
}上述,我们对判断是创建对象这一块进行了加锁,从而保证了创建对象的原子性.
但是,如果这样,由于我们每次都要判断是否有了对象实例,就要不停地加锁解锁,这就是一个开销比较高的事情了.
如何解决频繁的加锁解锁这个过程呢?
答案:
加锁 / 解锁是一件开销比较高的事情. 而懒汉模式的线程不安全只是发生在首次创建实例的时候.
因此后续使用的时候, 不必再进行加锁了,那么我们就在加锁之前判断是否已经有实例.使用双重if进行判断 .代码如下:
class MySingletonLazy2{
volatile private static MySingletonLazy2 instance = null;
public static MySingletonLazy2 getInstance(){
//外层的if,判定是否要加锁,如果对象已经有了,就没必要进行加锁,此时是线程安全的了,
//加锁 / 解锁是一件开销比较高的事情. 而懒汉模式的线程不安全只是发生在首次创建实例的时候.
//因此后续使用的时候, 不必再进行加锁了.
if (instance == null){
//解释:如果线程2执行到这里,发现对象还没创建,就会进行下一步,此时如果线程1正在创建对象,那么2就会进入堵塞状态,
// 等待线程1创建玩对象,锁解除,那么线程2此时判断对象已经建立,此时就不会创建新的对象,此时就保证了线程之间的安全.
synchronized (MySingletonLazy.class){
//保证原子性
if (instance == null){
instance = new MySingletonLazy2();
}
}
}
return instance;
}
}//解释:如果线程2执行到第一个if里面,发现对象还没创建,就会进行下一步,此时如果线程1正在创建对象,那么2就会进入堵塞状态,
// 等待线程1创建玩对象,锁解除,那么线程2此时判断对象已经建立,此时就不会创建新的对象,此时就保证了线程之间的安全.这就是上述加了双重if的好处.
细心的读者还会发现,上述代码instance的修饰加上了volatile关键字,这一步为了避免“内存可见性”导致读取的instance出现偏差，于是补充上volatile,这也是优化的关键一步.
