JUC之八锁现象理解锁

1.JUC概述

---

2.八锁应用 

Test1.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 1.标准情况下，两个线程打印，先打印？----- 发短信 打电话
 * 
 * @author Admin
 *
 */
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 {
		public synchronized void sendSms() {
			System.out.println("发短信");
		}

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

		}
	}

 控制台

发短信
打电话

---

Test2.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 2.sendSms延迟4秒，两个线程打印，先打印？----- 发短信 打电话
 * 
 * @author Admin
 *
 */
public class Test2 {

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

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

		//休眠
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone.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("打电话");

		}
	}

控制台

发短信
打电话

---

Test3.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 普通方法,打印，先打印？----- hello 发短信 
 * 
 * @author Admin
 *
 */
public class Test3 {

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

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

		//休眠
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone.hello();
		}, "B").start();

	}
}

class Phone3 {
//	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");
		}
	}

控制台

hello
发短信

---

Test4.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 两个对象，两个同步方法,打印，先打印？----- 打电话 发短信 
 * 
 * @author Admin
 *
 */
public class Test4 {

	public static void main(String[] args) {
//		两把锁
		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();

	}
}

class Phone4 {
//	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");
		}
	}

控制台

打电话
发短信

---

Test5.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 增加静态同步方法---发短信 打电话
 * 
 * @author Admin
 *
 */
public class Test5 {

	public static void main(String[] args) {

		Phone5 phone = new Phone5();
	
		
		new Thread(() -> {
			phone.sendSms();
		}, "A").start();

		//休眠
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone.call();
		}, "B").start();

	}
}

//唯一的class对象
class Phone5 {
//	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("打电话");

		}
		
//		普通方法,不受锁的影响
		public void hello() {
			System.out.println("hello");
		}
	}

控制台

发短信
打电话

---

Test6.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 增加静态同步方法---只有一个对象
 * 两个对象---发短信 打电话

 * @author Admin
 *
 */
public class Test6 {

	public static void main(String[] args) {

//		两个对象的类模板只有一个 static,锁的是class
		Phone6 phone1 = new Phone6();
		Phone6 phone2 = new Phone6();
		
		new Thread(() -> {
			phone1.sendSms();
		}, "A").start();

		//休眠
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone2.call();
		}, "B").start();

	}
}

//唯一的class对象
class Phone6{
//	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("打电话");

		}
		
//		普通方法,不受锁的影响
		public void hello() {
			System.out.println("hello");
		}
	}

控制台

发短信
打电话

---

Test7.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 打电话 发短信
 * @author Admin
 *
 */
public class Test7{

	public static void main(String[] args) {


		Phone7 phone = new Phone7();
		
		
		new Thread(() -> {
			phone.sendSms();
		}, "A").start();

		//休眠
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone.call();
		}, "B").start();

	}
}

//唯一的class对象
class Phone7{
//	synchronized 锁的对象是方法的调用者
//	static 静态方法，类一加载就有，锁的是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("打电话");

		}
		
//		普通方法,不受锁的影响
		public void hello() {
			System.out.println("hello");
		}
	}

控制台

打电话
发短信

---

Test8.java

package lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，是锁的8个问题
 * 打电话 发短信

 * @author Admin
 *
 */
public class Test8{

	public static void main(String[] args) {


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

		//休眠
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		new Thread(() -> {
			phone2.call();
		}, "B").start();

	}
}

//唯一的class对象
class Phone8{
//	synchronized 锁的对象是方法的调用者
//	static 静态方法，类一加载就有，锁的是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("打电话");

		}
		
//		普通方法,不受锁的影响
		public void hello() {
			System.out.println("hello");
		}
	}

控制台

打电话
发短信

---

3.锁总结

new     this:具体的一个类

static   Class:唯一的一个模板

本文地址：https://blog.csdn.net/weixin_44364444/article/details/110002361