剑指offer-单例设计模式

红太狼 2022-11-19 07:54 140阅读 0赞

## 懒汉模式与饿汉模式区别 ##

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

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();
    	        }
    	}
    	
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxNDgwNjA3_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxNDgwNjA3_size_16_color_FFFFFF_t_70]: /images/20221119/3df5971b17b54c428dd26100d106c46d.png