黑马程序员_多线程(下)

-------- android培训、 java培训、期待与您交流！--------

/*
同步函数：
同步函数使用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this
所以同步函数实使用的锁是this。


通过两个线程买票
一个线程在同步代码块中
一个线程在同步函数中
都在执行买票动作

发现还是出现不安全的情况

考虑两个前提：
1.必须是两个或者两个以上的线程（满足）
2.是不是用同一个锁（不满足）


如果同步函数被静态修饰后，使用是锁是什么？
通过验证，不是this，因为静态方法中也不可以定义this
静态进内存的时候内存中还没有建立对象，但一定有该类对应的字节码文件
类名.class 该对象的类型是Class

静态方法里面的锁不可能是this
静态的同步函数，使用的锁是该方法所在类的字节码文件对象， 类名.class

*/

class Ticket implements Runnable
{
	private static int tick = 100;//静态共数据
	boolean flag = true;
	Object obj = new Object();
	public void run()
	{
		if(flag)
		{
			while(true)
			{	
				//synchronized(Ticket.class)//证明静态同步函数用是锁是  类名.class
				synchronized(this)//该为this就安全了。证明了同步函数用的锁就是this
				//synchronized(obj)
				{
					if(tick>0)
					{
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"...code..."+tick--);
					}
				}
			}
		}
		else
			while(true)
			{
				show();
			}
	}
	//public static synchronized void show()//静态同步函数
	public synchronized void show()//同步函数
	{
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"...show..."+tick--);
		}
	}
}

class ThreadDemo5
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try
		{
			Thread.sleep(10);
		}
		catch (Exception e)
		{
		}
		t.flag = false;
		t2.start();
	

	}
}



/*
单例设计模式

//饿汉式

class Single
{
	private static final Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}
//懒汉式,特点：实例的延迟加载
  多线程的访问的时候，存在安全问题
  可以加同步来解决
  用同步函数和同步代码块效率有点低下
  用双重if语句判断来处理同步，可以解决效率问题
  加同步的时候，使用的锁是该类所属是字节码文件对象
class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{
				if(s==null)
					--A
				  s = new Single();
			}
		}
		return s;
	}
}

*/


/*
死锁：
    同步中嵌套同步
*/

class Test implements Runnable
{ 
	private boolean flag;
	Test(boolean flag)
	{
		this.flag = flag;
	}
	public void run()
	{
		if(flag)
		{
			synchronized(MyLock.locka)//同步中嵌套同步
			{
				System.out.println("if locka");//进程获得了a锁
				synchronized(MyLock.lockb)//需要b锁，但是b锁被下面的进程占用了
				{
					System.out.println("if lockb");
				}
			}
		}
		else
		{
			
			synchronized(MyLock.lockb)//同步中嵌套同步
			{
				System.out.println("else lockb");//进程获得了b锁
				synchronized(MyLock.locka)//需要a锁，但是a锁被上面的进程占用了，两个进程互不相让，导致死锁
				{
					System.out.println("else locka");
				}
			}
		}
	}
}

class MyLock
{
	static Object locka = new Object();//定义成静态方便调用
	static Object lockb = new Object();

}

class ThreadDemo7
{
	public static void main(String[] args) 
	{
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

-------- android培训、 java培训、期待与您交流！--------