JUC学习（2）8锁现象彻底理解锁

线程休息使用JUC包下的TimeUnit。

/**

*8锁，就是关于锁的8个问题

*1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话

*1、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话

*/

public class Test1 {

	public static void main(String[] args) {
	
		Phone phone = new Phone();

//锁的存在

		new Thread(()->{

			phone.sendSms();

		},"A").start();

		//捕获
		
		try { TimeUnit.SECONDS.sleep(1);
		
		} catch (InterruptedException e) {
		
			e.printStackTrace();

		}

		new Thread(()->{
		
			phone.call();
		
		},"B").start();
		
	}
		
}

class Phone{

	//synchronized 锁的对象是方法的调用者！、
	
	//两个方法用的是同一个锁，谁先拿到谁执行！ 
	public synchronized void sendSms(){

		try { TimeUnit.SECONDS.sleep(4);
	
		} catch (InterruptedException e) {
	
			e.printStackTrace();
	
		}

		System.out.println("发短信");
	
	}

	public synchronized void call(){

		System.out.println("打电话");

	}

}

/**

*3、 增加了一个普通方法后！先执行发短信还是Hello？ 普通方法

*4、 两个对象，两个同步方法， 发短信还是 打电话？ // 打电话

*/

public class Test2	{

	public static void main(String[] args) {

		//两个对象，两个调用者，两把锁！

		Phone2 phone1 = new Phone2(); 
		Phone2 phone2 = new Phone2();

		//锁的存在

		new Thread(()->{
		
			phone1.sendSms();
		
		},"A").start();

		//捕获
		
		try { TimeUnit.SECONDS.sleep(1);
		
		} catch (InterruptedException e) { 	
			e.printStackTrace();
		
		}

		new Thread(()->{
		
			phone2.call();
		
		},"B").start();
	
	}

}

class Phone2{

	//synchronized 锁的对象是方法的调用者！ 
	public synchronized void sendSms(){

		try {
		
		TimeUnit.SECONDS.sleep(4);
		
		} catch (InterruptedException e) { 
			e.printStackTrace();
		
		}

		System.out.println("发短信");

	}

	public synchronized void call(){
	
		System.out.println("打电话");
	
	}

	//这里没有锁！不是同步方法，不受锁的影响 
	public void hello(){

		System.out.println("hello");

	}

}

/**

*5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？

*6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？

*/

public class Test3	{

	public static void main(String[] args) {

		//两个对象的Class类模板只有一个，static，锁的是Class 
		Phone3 phone1 = new Phone3();
		Phone3 phone2 = new Phone3();

		//锁的存在
		
		new Thread(()->{

			phone1.sendSms();
		
		},"A").start();

		//捕获
		
		try { TimeUnit.SECONDS.sleep(1);
		
		} catch (InterruptedException e) { 
			e.printStackTrace();
		
		}

		new Thread(()->{
		
			phone2.call();
		
		},"B").start();
	
	}

}


// Phone3唯一的一个 Class 对象

class Phone3{

	//synchronized 锁的对象是方法的调用者！

	//static 静态方法

	//类一加载就有了！锁的是Class

	public static synchronized void sendSms(){

		try {
		
			TimeUnit.SECONDS.sleep(4);
		
		} catch (InterruptedException e) { 
			e.printStackTrace();
		
		}

		System.out.println("发短信");
		
}

	public static synchronized void call(){
	
		System.out.println("打电话");
	
	}
}

/**

*1、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？

*2、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？

*/

public class Test4	{

	public static void main(String[] args) {

		//两个对象的Class类模板只有一个，static，锁的是Class Phone4 phone1 = new Phone4();
		
		Phone4 phone2 = new Phone4(); //锁的存在

		new Thread(()->{ 
			phone1.sendSms();
		},"A").start();

		//捕获
		
		try {
		
			TimeUnit.SECONDS.sleep(1);
		
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}

		new Thread(()->{
		
			phone2.call();
		
		},"B").start();
		
	}

}

//Phone3唯一的一个 Class 对象 
class Phone4{

	//静态的同步方法 锁的是 Class 类模板
	
	public static synchronized void sendSms(){

		try {
		
			TimeUnit.SECONDS.sleep(4);
		
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}

		System.out.println("发短信");

	}

		//普通的同步方法 锁的调用者
		
	public synchronized void call(){
		
		System.out.println("打电话");
		
	}

}

小结：

new this 具体的一个手机
static Class 唯一的一个模板