java基础10 单例模式之饿汉式和懒汉式单例

前言: 软件行业中有23中设计模式

    单例模式
    模版模式
    装饰者模式
    观察者模式
    工厂模式
    ...........

单例模式

1. 单例模式包括

　　1.1 饿汉式单例
　　1.2 懒汉式单例

2. 概念

单例模式: 保证一个类中存在唯一的一个对象
模式: 模式就是解决某类问题的固定步骤

3. 单例模式步骤

      1.私有化构造器
      2.声明本类中的引用类型变量,并且使该变量指向本类对象
      3.提供一个公共的静态的方法获取该类的对象

4. 饿汉式单例(步骤)

    1.私有化构造器
   2.声明本类中引用类型变量,并且使该变量指向本类对象
   3.提供一个公共的静态方法获取本类中的对象

5. 懒汉式单例(步骤)

    1.私有化构造器
   2.声明本类中引用类型变量
   3.提供一个公共的静态方法获取本类中的对象,获取之前先判断是否已经创建本类中的对象,如果创建了,那么直接返回对象即可,如果没有创建,先创建本类中的对象,然后在返回.

6.数据类型

数据类型包括： 1. 基本数据类型；2. 引用数据类型

　6.1 基本数据类型：除了基本数据类型(四类八种),其他的都是引用类型.

　6.2 引用类型：数组、类、接口、抽象(类)等等。

7. 举例

 1 //饿汉式单例       //线程安全的
 2 class Single{
 3     private String name;
 4     //声明本类的引用类型变量,并且该变量指向本类对象
 5     private static Single sing = new Single();
 6     
 7     public void setName(String name){
 8         this.name = name;
 9     }
10     public String getName(){
11         return name;
12     }
13     //私有化构造器
14      private Single(){
15     
16     }
17     //提供一个公共的静态方法,用于获取本类中的对象
18     public static Single getInstance(){
19         return sing;
20     }
21 }
22 
23 //懒汉式单例     //线程不安全. 需要双重判断+使用同步方法,线程才安全.
24 class Single2{
25     private String name;
26     //声明本类的引用类型变量
27     private static Single2 single;
28         
29     public void setName(String name){
30         this.name = name;
31     }
32     public String getName(){
33         return name;
34     }
35     //私有化构造器
36     private Single2(){
37         
38     }
39     //提供一个公共的静态方法,用于获取本类中的对象
40     public static Single2 getInstance(){//synchronized(): 同步方法.  由于懒汉式单例线程不安全,所以才要使用同步方法和双重判断,才能保证线程安全
41         if(single == null){//可能同时存在多个线程进来(假如s2和s3同时进来)
42             /*第一个线程进来后,该方法被锁定,等第一个线程处理完并出来后(此时single有值了,所以第三个以后的进程不会走这步了),第二个进程才能进来.
43              *由于上一步是两个进程同时进来的,所以还会继续往下执行,进入同步方法.但是,由于上面进来的是两个不同的进程,那么会改变single的值,出现线程不安全的情况,所以同步方法中还要加一步判断
44              */
45             //synchronized(class):如果不同线程监视同一个实例或者不同的实例对象,都会等待．
46             synchronized(Single2.class){//Single2.class:监视器,监视Single2这个对象[指Single2 single = new Single2()]. 
47                 if(single == null){//此步,第二个进程不会再进来了,因为第一个进程进来后single已经有相对应的值,不再是NULL. 双重判断保证线程的安全
48                     single = new Single2();
49                 }
50             }
51         }
52         return single;
53     }
54 }
55 
56 class Demo7 {
57     public static void main(String[] args) {
58         //测试饿汉式单例
59         Single s = Single.getInstance();    
60         Single s1 = Single.getInstance();
61         s.setName("狗娃");
62         s1.setName("狗剩");
63         System.out.println(s.getName());
64         System.out.println(s1.getName());
65         
66         //下面是测试懒汉式单例
67         Single2 s2 = Single2.getInstance();    
68         Single2 s3 = Single2.getInstance();
69         s2.setName("张三");
70         s3.setName("李四");
71         System.out.println(s2.getName()+"==========");
72         System.out.println(s3.getName()+"==========");
73     }
74 }

结果图:

说明: 单例模式,保证一个类中只存在唯一的一个对象

8. 同步方法中的 "监视器"

synchronized(this) 与 synchronized(class) 相关知识: https://www.cnblogs.com/highriver/archive/2011/12/18/2291965.html

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：http://www.cnblogs.com/dshore123/p/8794288.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）