黑马程序员--锁

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

死锁含义：同步嵌套。

同步嵌套示例：

class Test implements Runnable
{
	private boolean flag;
	Test(boolean flag)
	{
		this.flag = flag; 
	}
	public void run()
	{
		if(flag)
		{
			synchronized(MyLock.lockb)//t1线程拿着MyLock.lockb锁
			{
			System.out.println("if lockb");
				synchronized(MyLock.locka)//如果它里边有线程那么上边的线程就进不来，判断有没有线程看是否执行到下边的else语句。
				{
					System.out.println("if locka");
				}
			}
		}
		else
		{
			synchronized(MyLock.locka)//t2线程进来拿着MyLock.locka锁，if语句中的线程就拿不到这个锁，死那了，线程执行完毕才消失
			{
				System.out.println("else locka");//当换成MyLock.lockb时，一个线程执行if语句且拿到MyLock.locka锁，那么其他线程执行到else语句时发现MyLock.lockb有线程进不去只能等
				synchronized(MyLock.lockb)
				{
					System.out.println("else lockb");
				}
			}
		}
	}
}
class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}
class  DeadLockTest
{
	public static void main(String[] args) //throws Exception
	{
		Test e= new Test(true);
		Test w = new Test(false);
		Thread t1 = new Thread(e);
		Thread t2 = new Thread(w);
		t1.start();
		//Thread.sleep(1000);  t2线程别占用else语句中的MyLock.locka锁。
		t2.start();
	}
}

1、虽然许多线程使用同一个锁，但是这个锁每次只能进去一个线程。如函数锁是this那么代码块对象（锁）也是this。只有共同使用同一个锁时才不会出现安全问题，（执行没
完毕就有别的线程进去参与了）
2、一个线程进入一个锁时，如果下一个的锁没有被占用那么此线程还可以继续进入这个锁。

同步函数使用的锁是this。
同步函数被静态修饰后使用的锁是；该类对应的字节码文件对象，类名.class   这个对象的类型是Class。

class Ticket implements Runnable 
{
	private int tick = 1000;
	public void run()
	{
		while (true)
		{
			synchronized(this)//这个也得是this ，两个使用同一个锁，才不会出现安全问题。
			{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+".....sale:"+tick--);
			}
		}
	}
	public synchronized void show()//这个锁是this
	{
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+".....sale:"+tick--);
		}
	}	
}
class  ThisLockDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
	}
}