vlambda博客
学习文章列表

package com.test.hibernate;

/*生成一个懒汉式单例的基础理解：1.Singleton顾名思义就是只能创建一个实例对象。。所以不能拥有public的构造方法2.既然构造方法是私有的，那么从外面不可能创建Singleton实例了。。只能从内部创建。。所以需要一个方法来创建此实例。。此方法肯定必须是static的3.静态的getInstance方法要返回一个Singleton实例。。就要一个Singleton类型的变量来存储。。声明一个Singleton类型的属性。。同样需要是static 的。。静态方法只能访问静态属性。。。！！！前3步是单例的共性！后三步是懒汉式需要考虑的地方！4.为了保证只生成一个实例，需要做判断是否为null5.此时考虑线程问题，假设有两个线程。。thread1，thread2。。thread1运行到判断那个Singleton类型的变量是否为null，然后跳到了thread2。。也运行到判断之后。。。此时两线程都得到single为空。。。那么就会有两个实例了。。。解决办法。。同步6.同步又要考虑效率，不能有太多的没用同步* */



//思考总结：其实饿汉式没什么问题，问题就是出现在懒汉式上，一般就是牵扯到执行效率和线程安全2个角度上来思考//个人感觉 如果是饿汉式就用天然的没毛病，如果想用懒汉式就用静态内部类方式吧//存在问题：如何在2个jvm上保证单例还未解决：这个就牵扯到分布式锁，可以用zookeeper来实现//还缺少一种懒汉式的枚举方式实现有待研究，听说这个方法也不错。

public class danli { //模拟一下静态代码块的使用方式，静态代码块在类加载的运行，先静态代码块》再构造代码块》再构造函数 ，只研究单例可以忽略

 public static final String STR1; static { STR1 = new String("zzh"); }

}//下面正式演示各种单例的实现：

class danli2{//单例饿汉式(非延时加载)，提前加载，有利于速度和反应时间，天然的线程安全的。没毛病 private danli2(){}; private static final danli2 two = new danli2();//final可加可不加，final的目的就是最终的，只允许一次赋值，但不加是因为没法在本类外给他赋值了，因为构造方法是私有的没法创建这个类的对象了，而且这个成员变量也是私有的所以不能在外面调用到，但是可以在本类中的其他方法调用到，所以其实还是可以修改的，所以还是加上final吧 public static danli2 getSingleInstance(){ return two; }}/*class danli2{//单例饿汉式(非延时加载)，提前加载，有利于速度和反应时间 private danli2(){}; public static final danli2 two = new danli2();//这里不能是public，否则在外面可以调用到，但是没法在本类外给他重新生成对象，因为外面无法使用构造方法，想在本类内部调用构造函数修改但用了final修饰只能被赋值一次！所以可以用public在这里修饰，所以可以用这种方式实现单例！

}*/





class danli3{ //单例懒汉式（延时加载），用的时候再去加载，有利于资源充分利用 private danli3(){}; private static danli3 three = null; public static synchronized danli3 getSingleInstance(){//加上synchronized变得线程安全了，但是效率下降了，每次还需要检查同步等等 if(three == null){//保证只生成一个实例 three = new danli3(); } return three; }}/* 该类跟上面那个是一样的 class Singleton {

 private Singleton() {}

 private volatile static Singleton instance = null;

 public static Singleton getInstance() {

 synchronized (Singleton.class) {//利用synchronized代码块，每次需要先检查有没有同步锁，效率较低，为了解决这个问题又提出了加入双层检查，也就是在这个同步代码块的外面再加一层为null判断，来减少除第一次以外的同步检查，提高了效率 if (instance == null) { instance = new Singleton(); } }

 return instance; }} */双重检查加锁就是在同步代码块的外面一层再来一个== null的判断，解决除第一次以外所有的同步判断导致的效率下降问题//但是这个双重检查加锁在多线程环境下存在系统崩溃的可能（一个线程初始化一半的对象，被第二个线程直接拿去用了，所以系统崩溃了）/*原因如下1、线程 1 进入 getInSingleton() 方法。2、由于 uniqueInstance 为 null，线程 1 在 //1 处进入 synchronized 块。3、线程 1 前进到 //3 处，但在构造函数执行之前，使实例成为非 null。4、线程 1 被线程 2 预占。5、线程 2 检查实例是否为 null。因为实例不为 null，线程 2 将 uniqueInstance 引用返回给一个构造完整但部分初始化了的 Singleton 对象。6、线程 2 被线程 1 预占。7、线程 1 通过运行 Singleton 对象的构造函数并将引用返回给它，来完成对该对象的初始化。

 */class Singleton {//双重检查加锁，线程相对安全了，避开了过多的同步（因为这里的同步只需在第一次创建实例时才同步，一旦创建成功，以后获取实例时就不需要同获取锁了），效率比上面那个能提高一些 // volatile关键字确保当uniqueInstance变量被初始化成Singleton实例时,多个线程正确地处理uniqueInstance变量，这个关键字其实也解决了上面说的系统可能崩溃的问题，因为使用这个变量也需要一个线程一个线程的来使用了 private volatile static Singleton uniqueInstance; private Singleton() { }

 public static Singleton getInSingleton() { if (uniqueInstance == null) {// 检查实例,如是不存在就进行同步代码区 synchronized (Singleton.class) {//1 // 对其进行锁,防止两个线程同时进入同步代码区 if (uniqueInstance == null) {//2 // 双重检查,非常重要,如果两个同时访问的线程,当第一线程访问完同步代码区后,生成一个实例;当第二个已进入getInstance方法等待的线程进入同步代码区时,也会产生一个新的实例 uniqueInstance = new Singleton();//3 } } } return uniqueInstance; } // ...Remainder omitted}

//使用静态内部类是没问题的，而且效率也不会降低，而且还是懒加载class Singleton2 {//jvm加载SingletonHolder的时候会初始化INSTANCE，所以既是lazy的又保证是单例的 private static class SingletonHolder {//静态内部类，只会被加载一次（在加载外部类的时候），所以线程安全，注意静态只能使用静态 static final Singleton2 INSTANCE = new Singleton2(); }

 private Singleton2 (){}//静态构造方法 

 public static Singleton2 getInstance() {//对外提供单例的接口 return SingletonHolder.INSTANCE; }}



class ceshi{//只是简单测试了一下单例，都为true,可以忽略 public static void main(String[] args) { System.out.println(danli.STR1 == danli.STR1);//true System.out.println(danli2.getSingleInstance() == danli2.getSingleInstance()); System.out.println(danli3.getSingleInstance() == danli3.getSingleInstance()); System.out.println(Singleton.getInSingleton() == Singleton.getInSingleton()); System.out.println(Singleton2.getInstance() == Singleton2.getInstance()); }}

public class Counter {  private static class CounterHolder{ private static final Counter counter = new Counter(); }  private Counter(){ System.out.println("init..."); }  public static final Counter getInstance(){ return CounterHolder.counter; }  private AtomicLong online = new AtomicLong();  public long getOnline(){ return online.get(); }  public long add(){ return online.incrementAndGet(); } .......}

public class SingleProperty {  private static Properties prop;  private static class SinglePropertyHolder{ private static final SingleProperty singleProperty = new SingleProperty(); }  /** * config.properties 内容是 test.name=kite  */ private SingleProperty(){ System.out.println("构造函数执行"); prop = new Properties(); InputStream stream = SingleProperty.class.getClassLoader() .getResourceAsStream("config.properties"); try { prop.load(new InputStreamReader(stream, "utf-8")); } catch (IOException e) { e.printStackTrace(); } }  public static SingleProperty getInstance(){ return SinglePropertyHolder.singleProperty; }   public String getName(){ return prop.get("test.name").toString(); }  public static void main(String[] args){ SingleProperty singleProperty = SingleProperty.getInstance(); System.out.println(singleProperty.getName()); }}