单例和多例

单例模式
两种写法：
一.懒汉式：
最简单的写法：怕多线程
中间的写法：无法实现多线程

双锁的写法：实现了线程安全，并保留了多线程。

特点：

1、单例类只能有一个实例。 

2、单例类必须自己创建自己的唯一实例。 

3、单例类必须给所有其他对象提供这一实例。

public class User {       

private String name;  

private int age;       

private User() {              }            

private static User user=null;      

 //静态工厂方法       

 public static User getUser() {           

 if (user == null) {                  

user = new User();           

 }            

 return user;       }   }   

以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个User实例，要 实现线程安全如下 第一种在getUser方法上加同步：

public class User {       

private String name;  

private int age;       

private User() {              }            

private synchronized static User user=null;      

 //静态工厂方法       

 public static User getUser() {           

 if (user == null) {                  

user = new User();           

 }            

 return user;       }   }   

第二种是双重检查锁定

package com.zhiyou100.model; 
 

public class User { 

 private String name;  private int age;   

 //2 声明一个静态User变量 

 private static User user=null;    

//1 私有化了构造方法  

private User() {     }  

//3 创建我们的user工厂  

public static User getUser() {     

 //如果user为空，   

if(user == null) {

//防止多次并发   

 //添加同步锁，让此代码块 只能进行但线程    

synchronized (User.class) {     

//如果线程进来的时候user==null    

 if(user==null) {

//防止第一次并发      //就创建一个user对象     

 user=new User();   

  }        

 }   

}  

 return user;  

 //如果user等于空就创建一个新的user,否则直接返回user   

  } 

二.饿汉式：

package com.zhiyou100.model; 
 

public class User {  

private String name;  private int age;  

  //2 声明一个静态User变量  

private static User user= new User();   

 //1 私有化了构造方法

  private User() {     } 

//3 创建我们的user工厂 

 public static User getUser() {    

  //如果user为空， 

  if(user == null) {

//防止多次并发    //添加同步锁，让此代码块 只能进行但线程    

synchronized (User.class) {    

 //如果线程进来的时候user==null     

if(user==null) {//防止第一次并发      

//就创建一个user对象      

user=new User();    

 }         }   } 

  return user;  

 //如果user等于空就创建一个新的user,否则直接返回user   

  } 

懒汉式和饿汉式的区别：
1.饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了 
 
懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。 
 
2.线程安全： 
 
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题， 
 
懒汉式本身是非线程安全的.

多例模式：

1 、多例类可以有多个实例 

 2 、多例类必须能够自我创建并管理自己的实例，并向外界提供自己的实例。

public class People {  

private static People man = null; 

 private static People woman = null;  

//私有化我们的构造方法 

 private People(){     }   

 public static People getPeople(String sex) {  

 if(sex.equals("man")) {    

return man;  

 } 

if(sex.equals("woman")) {   

 return woman;  

 }   

return null;  

 }  }   } 

线程安全的写法：

package com.zhiyou100.model; 
 

public class People {  

private static People man = null;  

private static People woman = null;  

//私有化我们的构造方法  

private People(){     }          

public static People getPeople(String sex) {   

if(sex.equals("man")) {     

if(man==null) {      

synchronized (People.class) {       

if(man==null) {           

man = new People();      

 }       }      

return man;      

}else {          return man;         }     }        

if(sex.equals("woman")) {     

if(woman==null) {      

synchronized (People.class) {       

if(woman==null) {               

woman = new People();       }      }      

return woman;     }

else {            

 return woman;             

}      }    

return null;   

}  }