Java单例模式懒汉和饿汉式

package com.wkcto.sigleton.p1;

/**
 * 饿汉单例模式
 *  在类加载内存时就给对象初始化,具有固有的线程安全性
 *  饿汉模式适用于成员属性比较少,占用内存资源不多的情况
 */
public class Test {
    public static void main(String[] args) {
        //创建10个线程, 在每个 线程中打印单例对象
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //调用Singleton.getInstance()返回单例对象,打印会输出对象的哈希码
                    System.out.println(Singleton.getInstance());
                }
            }).start();
        }
        //程序运行后,输出单例的哈希码都相同,说明是同一个对象
    }
}

package com.wkcto.sigleton.p1;

import java.util.Random;

/**
 * 单例类
 */
public class Singleton {
    //在使用Singleton单例类时,就给静态变量obj初始化. 在类加载内存时就已经对类的实例初始化完毕,保证在多线程环境中的唯一
    private static Singleton obj = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        try {
            Thread.sleep(new Random().nextInt(50));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

package com.wkcto.sigleton.p2;

/**
 * 测试单例模式
 */
public class Test {
    public static void main(String[] args) {
        //创建10个线程, 在每个 线程中打印单例对象
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //调用Singleton.getInstance()返回单例对象,打印会输出对象的哈希码
                    System.out.println(Singleton.getInstance());
                }
            }).start();
        }
    }
}

package com.wkcto.sigleton.p2;

import java.util.Random;

/**
 * 懒汉单例
 *  不是线程安全的
 */
public class Singleton1 {
    //定义本类实例,不初始化
    private static Singleton1 obj;
    private Singleton1(){}
    //在第一次调用getInstance()方法时,判断obj是否为null,如果obj为null就进行初始化
    public static Singleton1 getInstance(){
        if ( obj == null ){
            try {
                Thread.sleep(new Random().nextInt(50));     //睡眠,模拟多线程执行需要的时间,
                //加上睡眠后,运行结果可能会出现多个实例的情况,这种延迟加载不是线程安全的
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            obj = new Singleton1();
        }
        return obj;
    }
}

package com.wkcto.sigleton.p2;

import java.util.Random;

/**
 * 懒汉单例
 *  既然多个 线程可以同时调用getInstance()方法,只需要对该方法进行同步即可
 *  对整个方法进行了同步,并发效率低,即一个线程必须等上个线程释放锁之后才能取得 锁对象获得单例
 */
public class Singleton2 {
    //定义本类实例,不初始化
    private static Singleton2 obj;
    private Singleton2(){}
    //在第一次调用getInstance()方法时,判断obj是否为null,如果obj为null就进行初始化
    public static synchronized Singleton2 getInstance(){
        if ( obj == null ){
            try {
                Thread.sleep(new Random().nextInt(50));     //睡眠,模拟多线程执行需要的时间,
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            obj = new Singleton2();
        }
        return obj;
    }
}

package com.wkcto.sigleton.p2;

import java.util.Random;

/**
 * 懒汉单例
 *  直接同步getInstance()方法,并发效率低,可以只针对部分重要代码进行同步
 *  即只针对 给obj对象初始化的语句进行同步,也可能存在线程安全问题
 */
public class Singleton3 {
    //定义本类实例,不初始化
    private static Singleton3 obj;
    private Singleton3(){}
    //在第一次调用getInstance()方法时,判断obj是否为null,如果obj为null就进行初始化
    public static  Singleton3 getInstance(){
        if ( obj == null ){
            try {
                Thread.sleep(new Random().nextInt(50));     //睡眠,模拟多线程执行需要的时间,
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Singleton3.class) {
                obj = new Singleton3();
            }
        }
        return obj;
    }
}

package com.wkcto.sigleton.p2;

import java.util.Random;

/**
 * 懒汉单例
 *  直接同步getInstance()方法,并发效率低,可以只针对部分重要代码进行同步
 *  如果只针对 给obj对象初始化的语句进行同步,也可能存在线程安全问题
 *  可以采用双检查机制,在同步代码块中再次检查obj对象是否为null
 */
public class Singleton {
    //定义本类实例,不初始化
    private static Singleton obj;
    private Singleton(){}
    //在第一次调用getInstance()方法时,判断obj是否为null,如果obj为null就进行初始化
    public static Singleton getInstance(){
        if ( obj == null ){
            try {
                Thread.sleep(new Random().nextInt(50));     //睡眠,模拟多线程执行需要的时间,
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Singleton.class) {
                if (obj == null) {      //再次检查obj是否为null
                    obj = new Singleton();
                }
            }
        }
        return obj;
    }
}