剑指offer-单例设计模式

懒汉模式与饿汉模式区别

饿汉模式是最简单的一种实现方式， 饿汉模式在类加载的时候就对实例
进行创建， 实例在整个程序周期都存在。 它的好处是只在类加载的时候创建
一次实例， 不会存在多个线程创建多个实例的情况， 避免了多线程同步的问
题。 它的缺点也很明显， 即使这个单例没有用到也会被创建， 而且在类加载
之后就被创建， 内存就被浪费了。

package com.msc.design;

class Singleton{
	private static final Singleton INSTANCE = new Singleton() ;
	private Singleton() {
		  System.out.printf("****** 【%s】实例化Singleton类对象 *******\n",Thread.currentThread().getName());
	} ;
	public static Singleton getInstance() {
		return INSTANCE ;
	}
	public void print() {
		System.out.println("单例设计模式饿汉式");
	}
}
class Singletonb{
	 private static Singletonb instance ;
	 private Singletonb() {
		  System.out.printf("****** 【%s】实例化Singleton类对象 *******\n",Thread.currentThread().getName());
	 } ;
	 public static Singletonb getInstance() {
		 if(instance == null) {
			 instance = new Singletonb() ;
		 }
		 return instance ;
	 }
	 public void print() {
		 System.out.println("单例设计模式懒汉式");
	 }   
}
class Singletonc{
	private static volatile Singletonc instance ;
	private Singletonc() {  
		System.out.printf("****** 【%s】实例化Singleton类对象 *******\n",Thread.currentThread().getName());
		} ;
		public static Singletonc getInstance() {
			if(instance == null) {
				synchronized (Singletonc.class) {
					if (instance == null) {
						 instance = new Singletonc() ;
					}
				}
			}
			return instance ;
		}
	public void print() {
		System.out.println("线程安全懒汉式");
	}
}
/**
 * 这个时候的确是进行了同步处理，但这个同步处理的代价有些大，因为效率会低。
 * 因为整体代码中实际上只有一块部分需要进行同步处理，instance对象的实例化处理部分。
 * @author msc
 * Singletond
 */
class Singletond{
	private static volatile Singletond instance ;
	private Singletond() {
		System.out.printf("****** 【%s】实例化Singleton类对象 *******\n",Thread.currentThread().getName());
	}
	public static synchronized Singletond getInstance() {
		if(instance == null) {
			instance = new Singletond() ;
		}
		return instance ;
	}
	public void print() {
		System.out.println("单例设计模式懒汉式");
	}
}
class Singletone {
	private static class SingletonHodler {
	private static Singletone ourInstance = new Singletone();
	}
	public static Singletone getInstance() {
		return SingletonHodler.ourInstance;
	}
	private Singletone() {
		System.out.printf("****** 【%s】实例化Singleton类对象 *******\n",Thread.currentThread().getName());
	};
	public void print() {
		System.out.println("线程安全的懒汉式:静态内部类");
	}
}
public class DesignPattern {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		  System.out.println("---------------非线程安全懒汉式-------------");
		   for (int i = 0; i < 3; i++) {
	            new Thread(()->{
	                Singletonb.getInstance().print();
	            },"单例消费端-"+i).start();
	        }
		   Thread.sleep(1000);
		   System.out.println("---------------线程安全懒汉式-------------");
		   for (int i = 0; i < 3; i++) {
	            new Thread(()->{
	                Singletond.getInstance().print();
	            },"单例消费端-"+i).start();
	        }
		 	Thread.sleep(1000);
		   System.out.println("---------------饿汉式-------------");
		   for (int i = 0; i < 3; i++) {
	            new Thread(()->{
	                Singleton.getInstance().print();
	            },"单例消费端-"+i).start();
	        }
	}
	

}