21.单例模式

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了21.单例模式，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6671字，纯文字阅读大概需要10分钟。

内容图文

package simpleMode;
/*
 * 单利模式：
 * 保证一个类仅有一个实例，并提供一个访问他的全局访问点
 * 
 * 通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象，
 * 一个最好的方法就是让类自身保存他的对象实例，这个类可以保证没有其他实例被创建，
 * 并且他可以提供一个访问该实例的方法
 * 
 */
 public class SimpleMode {
	public static void main(String[] args) {
		/*//懒汉式  模拟线程不安全
		   new Thread(){
		         public void run() {
		        	 System.out.println("线程不安全："+Singleton1.getInstance().hashCode());
		         }
		   }.start() ;
		   new Thread(){
		         public void run() {
		        	 System.out.println("线程不安全："+Singleton1.getInstance().hashCode());
		         }
		   }.start() ;
		   //2次的hashCode不一样 说明创建了2个实例   这就是2个线程同时进入了 if (instance == null)
		   //所以导致了问题的出现  第一个线程判断为空之后创建一个实例 第二个线程如果后进去的话 是不为空的 但是
		   //他是和第一个线程一起进入到if (instance == null) 的  在他进入的时候 判断为空是true
		   
		   
		   //懒汉式 线程安全
		   //可以看到 线程安全打印出来的hashCode是相同的
		   //为什么线程安全呢？
		   //因为在getInstance方法上加了一个synchronized修饰符 多个线程不能同时访问次方法
		   //第二个线程要等第一个线程访问完 这个方法之后才能访问这个方法 这个时候instance就不是null了 所以就不会重新new 对象了
		   //这种方式很少用  因为synchronized 是程序的瓶颈  
		   new Thread(){
		         public void run() {
		        	 System.out.println("线程安全："+Singleton2.getInstance().hashCode());
		         }
		   }.start() ;
		   new Thread(){
		         public void run() {
		        	 System.out.println("线程安全："+Singleton2.getInstance().hashCode());
		         }
		   }.start() ;*/
		   
	//饿汉模式测试   2次输出是一样的
	/*System.out.println( Singleton3.getInstance().hashCode());
	System.out.println( Singleton3.getInstance().hashCode());*/
		   
	//枚举类型测试
	/*System.out.println(Singleton6.INSTANCE.getInstance().hashCode());
	System.out.println(Singleton6.INSTANCE.getInstance().hashCode());*/
	}
}



/*
 * 懒汉，线程不安全 
 * 懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的
 */
class Singleton1 {  
    private static Singleton1 instance;  
    private Singleton1 (){}  
    public static Singleton1 getInstance() {  
    if (instance == null) {  
    	//为了达到效果 这里sleep2秒 在高并发的情况下 
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {}
        instance = new Singleton1();  
    }  
    return instance;  
    }  
   
}  
/*
 * 懒汉，线程安全 
 */
class Singleton2{  
    private static Singleton2 instance;  
    private Singleton2 (){}  
    public synchronized static Singleton2 getInstance() {  
    if (instance == null) {  
    	//为了达到效果 这里sleep2秒 在高并发的情况下 
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {}
        instance = new Singleton2();  
    }  
    return instance;  
    }  
   
}  


/*
*饿汉式：
*饿汉式的特点是一开始就加载了，
*如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了
*这种方式基于classloder机制避免了多线程的同步问题，
*不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，
*在单例模式中大多数都是调用getInstance方法，
* 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
* 这时候初始化instance显然没有达到lazy loading的效果。
*/
 class Singleton3 {  
    private static Singleton3 instance = new Singleton3();  
    private Singleton3 (){
    	System.out.println("11111111111");
    }  
    public static Singleton3 getInstance() {  
    return instance;  
    }  
}  

 /*
  * 饿汉式 换汤不换药 跟上边一样
  */
 class Singleton4 {  
	    private  static  Singleton4 instance = null;  
	    static {  
	    instance = new Singleton4();  
	    }  
	    private Singleton4 (){}  
	    public static Singleton4 getInstance() {  
	    	return instance;
	    }  
	}  
 
 
 /*
 *静态内部类
 *这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，
 *它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，
 *那么instance就会被实例化（没有达到lazy loading效果），
 *而这种方式是Singleton类被装载了，instance不一定被初始化。
 *因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，
 *才会显示装载SingletonHolder类，从而实例化instance。
 *想象一下，如果实例化instance很消耗资源，我想让他延迟加载，
 *另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，
 *那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。
 */
 class Singleton5 {  
	    private static class SingletonHolder {  
	    private static final Singleton5 INSTANCE = new Singleton5();  
	    }  
	    private Singleton5 (){}  
	    public static final Singleton5 getInstance() {  
	    return SingletonHolder.INSTANCE;  
	    }  
	}  
 
/*
 * 枚举模式
 * 建议先看看关于枚举的相关知识
 * 首先，在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法，
 * 同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。
 * 在调用构造方法时，我们的单例被实例化。  
 * 也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。 
 * 可以看到，枚举实现单例还是比较简单的，
 * 
 * 
 *  《Effective Java》作者比较推崇这种做法  他说：单元素的枚举类型已经成为实现Singleton的最佳方法。
 */
  enum Singleton6 {  
	    INSTANCE;  
	    private Singleton77 instance;
	    Singleton6(){ 
	    	 instance = new Singleton77();
	    }  
	    public Singleton77 getInstance() {
	        return instance;
	    }
	}  
 class Singleton77{
	 
 }
 
 
 /*
  * 双重校验
  * 这个是第二种方式的升级版，俗称双重检查锁定
  * 这种方式使用比较多
  * volatile关键字 可以查阅相关资料：
  * 对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的 
  * 例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5， 那么都会加载这个最新的值
  * 在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6
  * 线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6
  * 导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。
  */
  class Singleton8 {  
	    private volatile static Singleton8 singleton;  
	    private Singleton8 (){}  
	    public static Singleton8 getSingleton() {  
	    //这里可能同时有2个线程进入 
	    if (singleton == null) {  
	    		//如果有多个线程进入 这里就会阻塞 但是这里基本没有线程进来 因为第一次初始化之后就不会进这里了
	        synchronized (Singleton8.class) {  
		        if (singleton == null) {  
		            singleton = new Singleton8();  
		        }  
	        }  
	    }  
	    return singleton;  
	    }  
	}  
  //SimpleMode.java
  
 
 /*
  *枚举相关知识 这里有一个连接 http://blog.csdn.net/qq_36291682/article/details/73824339 讲的凑合
  */

内容总结

以上是互联网集市为您收集整理的21.单例模式全部内容，希望文章能够帮你解决21.单例模式所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

---