单例模式与多线程

于 2017-04-26 11:47:40 发布
阅读量252 收藏
点赞数
分类专栏： java 多线程，单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/limin0983/article/details/70792535
版权 
如何使单例模式遇到多线程使安全的，正确的。
1.1单例模式之饿汉模式
      饿汉模式（立即加载）：就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接new 实例化。
      立即加载是在方法调用前，实例已经被创建了，实现代码如下：
package testSingleton;

public class MyObject {
     private static MyObject myObject = new MyObject();
     private MyObject(){}//将构造器私有
     public static MyObject getInstance(){
         return myObject;
     }
}

package testSingleton;

public class MyThread extends Thread {

	@Override
	public void run() {
		System.out.println(MyObject.getInstance().hashCode());
	}
	
}

package testSingleton;

public class Run {
	public static void main(String[] args) {
		MyThread myThread1 = new MyThread();
		MyThread myThread2 = new MyThread();
		MyThread myThread3 = new MyThread();
		myThread1.start();
		myThread2.start();
		myThread3.start();
	}
}
运行结果：
1251387847
1251387847
1251387847
   三个线程打印出来的hashCode是同一个值，说明对象是同一个，也就实现了立即加载型单例设计模式。

1.2 单例模式之懒汉模式
      懒汉模式（延迟加载）：就是在调用 getInstance() 方法时实例才被创建，常见的实现办法就是在getInstance() 方法中进行new 实例化。

    延迟加载是在调用方法时实例才被创建。实现代码如下：
package testSingleton;

public class MyObject {
     private static MyObject myObject;
     public static MyObject getInstance(){
	if(myObject == null){
             myObject = new MyObject(); 
         }
         return myObject;
     }
}
运行结果：
94165517
303479031
303479031
  在多线程中，hashCode值不相同，就会出现去除多个实例的情况，与单例模式的初衷违背。

1.3 如何在多线程环境中保证延迟加载型单例设计模式的正确性。

    解决方法1: 声明 synchronized 关键字
public static MyObject getInstance(){
  
}

直接在getInstance（）方法上加上 synchronized关键字，将其变为同步方法。

synchronized public static MyObject getInstance(){
  try{
   if(myObject == null){
      Thread.sleep(3000);//模拟在实例创建之前的一些准备工作
      myObject = new MyObject();
   }
  }catch(InterruptedException e){
      e.printStackTrace();
  }
    return myObject;

}



但是该方法运行效率非常低，是同步运行的，下一个线程想要取得对象，则必须等上一个线程释放之后，才可以继续执行。

 解决方法2：使用同步代码块

    同步方法是对方法整体进行持锁，这对运行效率来讲是不利的。
同步代码块1：
 public static MyObject getInstance(){
 
  try{
    synchronized(MyObject.class){
       if(myObject == null){
            Thread.sleep(3000);//模拟在实例创建之前的一些准备工作
           myObject = new MyObject();
       }
     }
  }catch(InterruptedException e){
      e.printStackTrace();
  }
    return myObject;

}

这样的同步代码块也可以实现单例模式，但是和同步方法效率一样低。
同步代码2：只对某些重要的代码进行单独同步
private static MyObject myObject ;
	public static MyObject getInstance(){
		
			try {
				if(myObject == null){
					Thread.sleep(3000);//模拟创建实例前的准备工作
					synchronized (MyObject.class) {
						myObject = new MyObject();
					}
				}
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			return myObject;
		
	}

运行结果：
94165517
1251387847
303479031
虽然效率提高了，但是并不能实现单例模式，即多线程下仍会得到多个实例对象。

解决方法3：使用DCL双重检查锁机制
      使用DCL双重检查锁机制来实现多线程环境中延迟加载单例设计模式。
     public static MyObject getInstance(){
              try{
			 if(myObject == null){
				 Thread.sleep(2000);//用来做创建对象前的一些准备工作
				 synchronized (MyObject.class) {
					if(myObject == null){
						myObject = new MyObject();
					}
				}
				 
			 }
		 }catch(InterruptedException e){
			 e.printStackTrace();
		 }
		return myObject;
     }


使用DCL双重检查锁机制，成功解决了“懒汉模式” 遇到多线程的问题。DCL也是大多数多线程结合单例模式使用的解决方案。

1.4 使用静态内置类实现单例模式


public class MyObject{
     private static class MyObjectHandler{
          public static MyObject myObject = new MyObject();
     }
    private MyObject(){}
    public static MyObject getInstance(){
	return MyObjectHandler.myObject;
    }

}

同样可以在多线程环境中实现单例模式。但是，如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。

  情况1：反序列化时使用默认方式，会破坏单例模式
package testSingleton;

import java.io.Serializable;

public class MyObject2 implements Serializable{

	private static final long serialVersionUID = 1L;
	private static class MyObjectHandler{
		public static MyObject2 myObject = new MyObject2();
	}
	
	private static MyObject2 myObject2 ;
	private MyObject2(){}
	public static  MyObject2 getInstance(){
		return MyObjectHandler.myObject;
	}
	/*默认模式没有该方法
	protected Object readResolve() {
		System.out.println("调用了readResolve() 方法");
		return MyObjectHandler.myObject;
	}
	*/
	
}
package testSingleton;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SaveAndRead {
	public static void main(String[] args) {
		try{
			MyObject2 myObject2 = MyObject2.getInstance();
			FileOutputStream out = new FileOutputStream(new File("myObject2.txt"));
			ObjectOutputStream oot = new ObjectOutputStream(out);
			oot.writeObject(myObject2);
			oot.close();
			out.close();
			System.out.println(myObject2.hashCode());
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}
		
		try{
			FileInputStream in = new FileInputStream(new File("myObject2.txt"));
			ObjectInputStream oi = new ObjectInputStream(in);
			MyObject2 myObject2 = (MyObject2)oi.readObject();
			System.out.println(myObject2.hashCode());
			oi.close();
			in.close();
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
	}
}


运行结果：
865113938
1283928880
破坏了单例模式，解决方法就是在MyObject2中加入 readResolve() 方法，并指定要返回对象myObject的生成方式。

情况2： 在Singleton中 定义readResolve() 方法，可以防止反序列化时破坏单利模式

package testSingleton;

import java.io.Serializable;

public class MyObject2 implements Serializable{

	private static final long serialVersionUID = 1L;
	private static class MyObjectHandler{
		public static MyObject2 myObject = new MyObject2();
	}
	
	private static MyObject2 myObject2 ;
	private MyObject2(){}
	public static  MyObject2 getInstance(){
		return MyObjectHandler.myObject;
	}
	//加入了readResolve()方法
	protected Object readResolve() {
		System.out.println("调用了readResolve() 方法");
		return MyObjectHandler.myObject;
	}
	
	
}

运行结果：
865113938
调用了readResolve() 方法
865113938

实现了单例模式

解析：为什么在MyObject2类中加入了readResolve()方法就可以防止反序列化时破坏单例模式呢？
对象序列化过程通过ObjectOutputStream 和ObjectInputStream 来实现，下面看看ObjectInputStream中的readObject() 方法时如何执行的。

这里只给出ObjectInputStream 的readObject() 方法的调用栈：

 readObject() ---> readObject0() ---> readOrdinaryObject() --> checkResolve()

下面只给出重点代码块，readOrdinaryObject() 方法的代码：
/**
     * Reads and returns "ordinary" (i.e., not a String, Class,
     * ObjectStreamClass, array, or enum constant) object, or null if object's
     * class is unresolvable (in which case a ClassNotFoundException will be
     * associated with object's handle).  Sets passHandle to object's assigned
     * handle.
     */
    private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }

        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }

        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }

        handles.finish(passHandle);

        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                // Filter the replacement object
                if (rep != null) {
                    if (rep.getClass().isArray()) {
                        filterCheck(rep.getClass(), Array.getLength(rep));
                    } else {
                        filterCheck(rep.getClass(), -1);
                    }
                }
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
    }

isInstantiable :如果一个serializable / externalizable 的实现类可以在运行时被实例化，那么该方法就返回true。

desc.newInstance : 该方法通过反射的方式调用无参构造方法金建一个对象。

这就是为什么序列化会破坏单例了。答案：序列化会通过反射调用无参构造方法创建一个新的对象。

如何防止序列化/反序列化破坏单例模式：
防止序列化破坏单例模式： 解决方法就是在Singleton类中定义readResolve() 方法。如上述的例子。
原因：

   hasReadResolveMethod() : 如果在实现了serializable 或着 externalizable 接口的类中 包含readResolve() 方法，就返回true；
   invokeReadResolve() : 通过反射的方式调用要被反序列化的类中的eadResolve() 方法。
所以：只要在Singleton类中定义readResolve() 方法，并且在该方法中指定要返回对象的生成策略，就可以防止单例模式被破坏了。

limin0983
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值