多线程环境下实现各种情形的单例模式

骑猪看日落 2023-07-03 12:18 41阅读 0赞

## （1）饿汉模式 ##

package singleton;
    
    /**
     *  饿汉模式 多线程环境下实现单例模式
     * @author zc
     *
     */
    public class SingletonE {
    
    	//立即加载 饿汉模式
    	private static SingletonE singleton=new SingletonE();
    	
    	//私有化构造方法
    	private SingletonE() {
    		
    	}
    	
    	public static SingletonE  getInstance() {
    		return singleton;
    	}
    	
    	public static void main(String[] args) {
    		
    		MyThread t1 = new MyThread();
    		MyThread t2 = new MyThread();
    		MyThread t3 = new MyThread();
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    
    class MyThread extends Thread{
    	
    	@Override
    	public  void run() {
    		System.out.println(SingletonE.getInstance().hashCode());
    	}
    	
    }

## （2）懒汉模式 ##

package singleton;
    
    /**
     *  双加锁机制 实现懒汉模式的多线程环境下的单例模式
     * @author zc
     *
     */
    public class SingletonL {
    	
      private volatile static SingletonL singleton ;
      
      private SingletonL() {
    	  
      }
      public static SingletonL getInstance() throws InterruptedException {
    	  if(singleton==null) {
    		  //模拟实例化之前的准备工作
    		  Thread.sleep(2000);
    	      synchronized(SingletonL.class) {
    	    	  
    	    	  if(singleton==null) {
    	    		  singleton =new SingletonL();
    	    	  }
    	      }
    	  }
    	  return singleton;
      }
      
      public static void main(String[] args) {
    	  
    	MyThread2 t1 = new MyThread2();
    	MyThread2 t2 = new MyThread2();
    	MyThread2 t3 = new MyThread2();
    	 
    	t1.start();
    	t2.start();
    	t3.start();
    }
      
    }
    class MyThread2 extends Thread{
    	
    	@Override
    	public  void run() {
    		try {
    			System.out.println(SingletonL.getInstance().hashCode());
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    }

## （3）静态内置类 ##

package singleton;
    
    /**
     * 静态内置类实现多线程环境下的单利模式
     * @author zc
     *
     */
    public class SingletonInner {
     
    	private static class SingletonInnerHandler{
    		private static SingletonInner singleton = new SingletonInner();
    	}
    	//私有化构造方法
    	private SingletonInner() {
    		
    	}
    	
    	public static SingletonInner getInstance(){
    		 
    		return SingletonInnerHandler.singleton;
    	}
    	
    	public static void main(String[] args) {
    		
    		MyThread3 t1= new MyThread3();
    		MyThread3 t2= new MyThread3();
    		MyThread3 t3= new MyThread3();
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    class MyThread3 extends Thread{
    	
    	@Override
    	public  void run() {
    		System.out.println(SingletonInner.getInstance().hashCode());
    	}
    	
    }

## （4）序列化和反序列化 ##

package singleton;
    
    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;
    import java.io.ObjectStreamException;
    import java.io.Serializable;
    /**
     *   多线程环境下序列化和反序列化的单例模式
     * @author zc
     *
     */
    public class SingletonSerializable  implements Serializable{
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	
    	//内部类的方式
    	private static class SingletonSerializableHandler{
    		
    		private static final SingletonSerializable singelton = new SingletonSerializable();
    	}
    	//私有化构造函数
    	private SingletonSerializable() {
    		
    	}
    	
    	public static SingletonSerializable getInstance() {
    		
    		return SingletonSerializableHandler.singelton;
    	}
    	//序列化需要重写这个方法
    	protected Object readResolve() throws ObjectStreamException{
    		System.out.println("调用了readResolve方法");
    		return SingletonSerializableHandler.singelton;
    	}
    	
    	public static void main(String[] args)  {
    		
    		SingletonSerializable myObject =SingletonSerializable.getInstance();
    		
    		//向文件写入对象，序列化对象
    		try {
    		FileOutputStream 	fout = new FileOutputStream(new File("myobject.tx"));
    		ObjectOutputStream  oout= new ObjectOutputStream(fout);
    		oout.writeObject(myObject);
    	    oout.close();
    		fout.close();
    		System.out.println(myObject.hashCode());
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		
    		//读出对象，反序列化对象
    		try {
    			FileInputStream 	finput = new FileInputStream(new File("myobject.tx"));
    			ObjectInputStream  oinput= new ObjectInputStream(finput);
    			SingletonSerializable myObject2 = (SingletonSerializable) oinput.readObject();
    			oinput.close();
    			finput.close();
    				System.out.println(myObject2.hashCode());
    			} catch (FileNotFoundException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    		    } catch (ClassNotFoundException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		
    			
    	}
       
    	
    }

## （5） enum枚举 ##

package singleton;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    /**
     *  使用enum枚举实现多线程环境下的单例模式
     * @author zc
     *
     */
    public class SingletonEnum {
      
    	public enum MyEnumSingleton{
    		
    		connectionFactory;
    		//mysql连接
    		private Connection connection;
    		//构造函数
    		private MyEnumSingleton() {
    			
    			
    			try {
    				System.out.println("创建MyObject对象");
    				String url="jdbc:mysql://localhost:3306/sakila?useUnicode=true&characterEncoding=UTF-8";
    				String username="root";
    				String password="root";
    				String driverName="com.mysql.jdbc.Driver";
    				Class.forName(driverName);
    				connection =DriverManager.getConnection(url,username,password);
    			} catch (ClassNotFoundException | SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    		}
    		
    		public Connection  getConnection() {
    			return connection;
    		}
    		
    	}
    	//外层封装连接
    	public static Connection getConnection() {
    		
    		return MyEnumSingleton.connectionFactory.getConnection();
    	}
    	
    	public static void main(String[] args) {
    		
    		MyThread4 t1 = new MyThread4();
    		MyThread4 t2 = new MyThread4();
    		MyThread4 t3 = new MyThread4();
    	    t1.start();
    	    t2.start();
    	    t3.start();
    		
    	}
    }
    class MyThread4 extends Thread{
    	
    	@Override
    	public  void run() {
    		System.out.println(SingletonEnum.getConnection().hashCode());
    	}
    	
    }