java 单例 饿汉式_Java单例模式懒汉和饿汉式

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;

}

}

懒汉模式

懒汉模式也称为延迟加载. 延迟加载就是在第一次调用get()方法时才给实例进行初始化。

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;

}

}