单例设计模式之懒汉模式

<pre name="code" class="java">package thread;

/*
 * 单例设计模式：懒汉式
 * 
 * 具有延时加载的特点
 */

class Single{
	private Single(){}
	private static Single s=null;
	private int num;
	
	//在这里加synchronized也可以，只不过效率低
	public static Single getSingle(){
		
		/*
		 * 这个判断条件是为了创建了对象后不用在进去里面执行了
		 * 有效提高了执行效率
		 */
		if(s==null){
		synchronized(Single.class){
			/*
			 * 在下面再加一个判断条件
			 * 是为了防止两条线程都过了第一个判断条件的时候，
			 * 一个线程进去执行后释放锁，第二个线程如果不再加一个判断条件的话，
			 * 会出现再新建一个对象，就不符合情况了。
			 */
		if(s==null){
			s=new Single();
				}
			}
		}
		return s;
	}
	
	public void setNum(int num){
		this.num=num;
	}
	public int getNum(){
		return num;
	}
}

public class SingleTest {

	public static void main(String[] args) {
		Single s,s1;
		s=Single.getSingle();
		s1=Single.getSingle();
		s.setNum(3);
		System.out.println(s.getNum());
		System.out.println(s1.getNum());
	}

 

 

 

 

另外附加一个恶汉模式，开发基本用恶汉模式，因为懒汉模式有线程安全问题,且执行效率低

 

class singleTest2{
	private void SingleTest2(){}//私有化默认构造方法
	
	//类加载进来对象的引用就存在了，用final修饰不能再改变
	private final static singleTest2 s=new singleTest2();
	private int num;
	
	public static singleTest2 getSingleTest(){
		return s;
	}
	
	public void setNum(int num){
		this.num=num;
	}
	public int getNum(){
		return num;
	}
}
public class Single2 {
	
	public static void main(String[] args){
		singleTest2 x=singleTest2.getSingleTest();
		singleTest2 x1=singleTest2.getSingleTest();
		x.setNum(2);
		
		System.out.println(x.getNum());
		System.out.println(x1.getNum());
	}
}