package com.Thread;
/**
* 单例设计模式：确保一个类只有一个对象
*/
public class Synchronized_Singleton {
public static void main(String[] args) {
JvmThread jvm1= new JvmThread(100);
JvmThread jvm2= new JvmThread(100);
jvm1.start();
jvm2.start();
}
}
/**
* 懒汉式（饿汉式：在声明静态变量时直接创建）
*1、构造器私有化，避免外部直接创建对象
*2、声明一个私有静态变量（饿汉式 = new()）
*3、创建一个对外公开的静态方法 访问该变量，如果变量没有对象，直接创建对象
*
*/
//饿汉式
class HungryJVM {
// 提高效率，类在使用时才加载，创建类时会初始化变量
private static class Holder {
private static HungryJVM instance = new HungryJVM();
}
private HungryJVM() {
}
public HungryJVM getInstance() {
//创建HungryJVM时不会初始化instance，这个方法被调用时才初始化
return Holder.instance;
}
}
//懒汉式
class JVM {
//2、声明一个私有静态变量
private static JVM instance = null;
//1、构造器私有化，避免外部直接创建对象
private JVM() {
}
//3、创建一个对外公开的静态方法 访问该变量，如果变量没有对象，直接创建对象
//双重检查 double checking
public static JVM getInstance(long time) throws Exception {
//效率高--a b c d e f 进来只要有实例就直接返回
if(instance ==null) {
synchronized(JVM.class ) {
if(instance == null) {
Thread. sleep(time);//放大错误，线程延时
instance = new JVM();
}
}
}
return instance ;
}
//锁类的字节码.class
public static JVM getInstance3(long time) throws Exception {
//效率不高--a b c d e f 进来都要等待
synchronized(JVM.class ) {
if(instance == null) {
Thread. sleep(time);//放大错误，线程延时
instance = new JVM();
}
return instance ;
}
}
//最简单的锁定对象
public static synchronized JVM getInstance2(long time) throws Exception {
if(instance == null) {
Thread. sleep(time);//放大错误，线程延时
instance = new JVM();
}
return instance ;
}
//线程不安全
public static JVM getInstance1(long time) throws Exception {
if(instance == null) {
Thread. sleep(time);//放大错误，线程延时
instance = new JVM();
}
return instance ;
}
}
//放大错误，模拟网络延时
class JvmThread extends Thread{
private long time ;
public JvmThread(long time) {
this.time = time;
}
public void run() {
try {
System. out.println(Thread.currentThread().getName() + "-->" + JVM.getInstance( time));
} catch (Exception e) {
e.printStackTrace();
}
}
}
