设计模式--》单例模式（创建型模式）

ps：记录各个设计模式，第一篇自己写的对于单例模式的理解。但是之前看过许多关于单例模式的文章，所以算在转载里面，属于自己整理和理解的内容。

 

1.单例模式-->保证在运行过程中只有一个类的实例

2.单例模式：饿汉式-->类一加载就加载类的实例对象

/**
 * 功能： 
 * 〈单例模式演示：饿汉式〉
 *
 * @author HelloLoging
 * @create 2019/3/7
 * @since 1.0.0
 */

public class TestB {

    private Integer id;
    private String name;
    private static TestB testB;
    static{
        testB =  new TestB();
    }

    private TestB(){
        Random random = new Random(100);
        id = random.nextInt();
        name = UUID.randomUUID().toString().substring(0,10);
    }

    public static TestB getInstance(){
        return testB;
    }

    @Override
    public String toString() {
        return "TestB{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

测试：

    /* 饿汉式：当类文件加载时，就加载实例对象*/

TestB instance1 = TestB.getInstance();

System.out.println("1---"+instance1.toString());

TestB instance2 = TestB.getInstance();

System.out.println("2---"+instance2.toString());

TestB instance3 = TestB.getInstance();

System.out.println("3---"+instance3.toString());

 

3.单例模式：懒汉式-->当调用获取实例对象方法时，才加载该类实例对象，本身线程不安全

/**
 * 功能： 
 * 〈多线程时单例模式演示：懒汉式
 *         当调用获取实例方法时，才加载实例对象
 * 〉
 *
 * @author HelloLoging
 * @create 2019/3/7
 * @since 1.0.0
 */

public class MultithreadTestA {

    private Integer id;
    private String name;
    private static MultithreadTestA testA;
    private static Object object = new Object();
    private static Lock lock = new ReentrantLock();


    private MultithreadTestA(){
        Random random = new Random(100);
        id = random.nextInt();
       name = UUID.randomUUID().toString().substring(0,10);
    }

    /**
     * 功能描述:
     * 〈线程安全：
     * 方法1：在获取实例方法上加上synchronized 关键字
     *      线程安全，效率低，其它线程等待时间可能会很长
     * 〉
     *
     * @return:
     */
//    public synchronized   static MultithreadTestA getInstance(){
//        if (testA==null){
//            testA =  new MultithreadTestA();
//        }
//        return testA;
//    }
    /**
     * 功能描述:
     * 〈
     * 线程安全：
     *      方法2：在创建实例资源时加上synchronized 关键字 代码块
     *          线程安全，效率低(比在方法上加会好些)，其它线程等待时间可能会很长
     *  〉
     *synchronized锁住的是括号里的对象，而不是代码。
     * 对于非static的synchronized方法，锁的就是对象本身也就是this。
     * @return:
     */

//    public  static MultithreadTestA getInstance(){
//        if (testA==null){
//            synchronized(object){
//                testA =  new MultithreadTestA();
//            }
//        }
//        return testA;
//    }
    /**
     * 功能描述:
     * 〈线程安全：
     *     方法3：在创建实例资源时加上 lock锁
     *        线程安全，效率低(比在方法上加会好些)，其它线程等待时间可能会很长
     *  〉
     *
     * @return:
     */

    public  static MultithreadTestA getInstance(){
        if (testA==null){
            lock.lock();
            testA =  new MultithreadTestA();
            lock.unlock();
        }
        return testA;
    }

    @Override
    public String toString() {
        return "TestA{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

 

测试：

/*   懒汉式：当调用获取实例方法时，才加载实例对象*/
   TestA instance1 = TestA.getInstance();
   System.out.println("1---"+instance1.toString());

   TestA instance2 = TestA.getInstance();
   System.out.println("2---"+instance2.toString());

   TestA instance3 = TestA.getInstance();
   System.out.println("3---"+instance3.toString());