一、多线程下的单例设计模式

利用双重推断的形式解决懒汉式的安全问题和效率问题

//饿汉式
/*class Single
{
	private static final Single t = new Single();
	private Single(){} //private构造函数，确保其它类对象不能直接new一个该对象实例

	public static Single getInstance()
	{
		return t;
	}
}
*/

//懒汉式
class Single
{
	private static Single t = null;
	private Single(){} 
	public static Single getInstance()   //同步函数就不是必需了，同步整个函数致使效率减少
	{
		if(t==null)//解决效率问题
		{
				synchronized(Single.class)//解决安全问题
				{
					if(t==null)
						t = new Single();
				}
			
		}
		return t;
	}
}

二、死锁演示样例

死锁是线程间相互等待锁锁造成的

死锁：常见就是，同步的嵌套

面试时。会让写死锁程序，仅仅要写的出来。就说明死锁已经理解

class Deadlock implements Runnable
{
	private boolean flag;
	public Deadlock(boolean flag) {
		// TODO Auto-generated constructor stub
	this.flag = flag;
	}
	public void run()
	{
		if(flag)
		{
			while(true)
			synchronized (lock.A_LOCK) {
				System.out.println("if...alock");
				synchronized (lock.B_LOCK) {
					System.out.println("if...block");
				}
			}
		}
		else {
			while(true)
			synchronized (lock.B_LOCK) {
				System.out.println("else...block");
				synchronized (lock.A_LOCK) {
					System.out.println("else...alock");
					
				}
			}
		}
	}
}

class lock
{
	public static final Object A_LOCK = new Object();
	public static final Object B_LOCK = new Object();
	
}
class Main
{
	public static void main(String[] args)
	{
		Deadlock t1 = new Deadlock(true);
		Deadlock t2 = new Deadlock(false);
		Thread j1 = new Thread(t1);
		Thread j2 = new Thread(t2);
		j1.start(); j2.start();
		
	}
}

锁上了，j1线程拿a锁，j2线程拿b锁，两者都在等待，可是不释放锁，就形成了死锁，致使程序死掉，在开发中发生死锁的概率很低。

由于在代码内某处，CPU肯定会切换还有一线程，所以死锁的情况发生的概率极低。可是一旦发生，程序就会彻底卡壳

关于线程同步问题和锁的总结：