单例模式(多线程不安全,序列化不安全,反射不安全实例)

原创 2015年11月19日 12:33:31
<pre name="code" class="html">import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Type;


public class SingletonTwo implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private int number;
	
	
	private  final static SingletonTwo s=new SingletonTwo();
	
	private SingletonTwo(){}
	
	private SingletonTwo(int number){
		this.number=number;
	}
	public  static SingletonTwo getInstace()
	{
		return s;
	}
	public void sayHello(){
		System.out.println("hello");
	}
	
	
	
	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}
	
	 /*private Object readSolve()
	 {
		 return s;
	 }*/ 此段代码保证反序列化的安全性
	 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		SingletonTwo s=SingletonTwo.getInstace();//原始类
		s.sayHello();
		s.setNumber(10);
		ObjectOutputStream out;
		
		
		//反序列化不安全
		try {
			
			//序列化
			out = new ObjectOutputStream(new FileOutputStream("E://Singleton.txt"));
			out.writeObject(s);
			System.out.println("序列化成功");
			out.close();
			//反序列化
			 ObjectInputStream in = new ObjectInputStream(new FileInputStream("E://Singleton.txt"));
			 SingletonTwo dest=(SingletonTwo) in.readObject();
			 dest.setNumber(100);
			 System.out.println(dest.getNumber());
			 System.out.println("原始类 和 反序列话类相等吗  "+s.equals(dest));
			
		} catch (FileNotFoundException e1) {
			// TODO 自动生成的 catch 块
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO 自动生成的 catch 块
			e1.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	   
	    
	    
		MyThread m=new MyThread(s);//多线程不安全
		new Thread(m).start();
		MyThread m1=new MyThread(s);
		new Thread(m1).start();
		
		
		System.out.println("我是单例类"+s.getNumber());
		try {//私有的反射机制不安全
			Constructor<SingletonTwo>[] c=(Constructor<SingletonTwo>[]) Class.forName("com.create.destroy.object.singleton.SingletonTwo").getDeclaredConstructors();
			for(int i=0;i<c.length;i++)
			{
				Constructor<SingletonTwo> cs=c[i];
				Type []types=cs.getGenericParameterTypes();
				if(types!=null && types.length>0)
				{
					for(int j=0;j<types.length;j++)
					{
						System.out.println(types[j]);
					}
				}else
				{
					SingletonTwo st=cs.newInstance(null);
					 st.setNumber(1);
					 System.out.println("原始类 和 反射类相等吗  "+st.equals(s));
					
				}
			}
		} catch (SecurityException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	  
	
	}

}
class MyThread implements Runnable{
	private SingletonTwo s;
	/* (非 Javadoc)
	 * @see java.lang.Runnable#run()
	 */
	public MyThread(SingletonTwo s)
	{
		this.s=s;
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		SingletonTwo t=SingletonTwo.getInstace();
		System.out.println("********************************************************");
		System.out.println("1.多线程类和原始类相等吗?"+s.equals(t));
		System.out.println("如果再多线程中使用反序列化还会相等吗??? 使用反射机制呢??");
		System.out.println("*************************可能为false****************************** ");
	}
	
}
总结如下:通过反射机制,一定不安全。多线程可能造成不安全,序列化也可能造成不安全




            
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

多线程锁和反射的再次理解

只有对象才有锁,一个对象有且只有一把锁。   只能使用对象的锁去同步,且只能同步方法/代码块,而不能同步变量和类;   同步损害并发性,应尽可能缩小同步范围。   分类  1代码块锁,2方法锁 同步整...

java基础---------多线程与反射

多线程: java语言是为数不多的支持多线程的语言。 进程:当程序进入内存运行时,即变成了一个进程。进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位。 ...

解决多线程单例模式的线程不安全问题

DCL双检查锁机制public class MyConfig { private volatile static MyConfig myConfig = null;//volatile 保证每...

单例设计模式详解一:不安全的懒汉式(多线程环境验证)

单例设计模式详解一:不安全的懒汉式(多线程环境验证)单例设计模式详解一不安全的懒汉式多线程环境验证 写在前面的话 饿汉式 懒汉式 验证在多线程环境下懒汉式单例写法的不安全之处 写在前面的话前言:虽然工...

libcurl多线程超时设置不安全

(1), 超时(timeout) libcurl 是 一个很不错的库,支持http,ftp等很多的协议。使用库最大的心得就是,不仔细看文档,仅仅看着例子就写程序,是一件危险的事情。我的程序崩溃了,我...

1、关于HashMap在多线程下的不安全分析

原文网址:http://coolshell.cn/articles/9606.html/comment-page-1#comments 1、问题的症状   从前我们的Java代码因为一些原因使用了...

iOS多线程到底不安全在哪里?

iOS多线程安全的概念在很多地方都会遇到,为什么不安全,不安全又该怎么去定义,其实是个值得深究的话题。 共享状态,多线程共同访问某个对象的property,在iOS编程里是很普遍的使用场景,我们就从...

写一下单例模式,考虑线程安全与线程不安全的情况

凡是提到设计模式,面试官很喜欢问最简单的单例模式。单例模式最简单的写法如下public class SingletonPatternA { private static SingletonPat...

JAVA多线程不安全问题解决方案(多线程并发同一资源)。

引例:吃苹果比赛,3个人同时吃50个苹果,谁先拿到谁就吃,每个哦ing过都有编号。 问题: 多线程同时执行的时候可能出现不安全问题 当3个人同时拿到一个苹果,他们的编号就一样,当时主要看是谁先吃掉苹果...

懒汉式单例设计模式线程不安全

懒汉式:延迟加载方式。(先不new,等用到的时候再进行实例化)单例设计模式点击查看 [java] view plain copy   class single2{       &...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)