欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

JUC之八锁现象理解锁

程序员文章站 2022-06-03 23:38:34
1.JUC概述2.八锁应用Test1.javapackage lock8;import java.util.concurrent.TimeUnit;/** * 8锁，是锁的8个问题 * 1.标准情况下，两个线程打印，先打印？----- 发短信 打电话 * * @author Admin * */public class Test1 {public static void main(String[] args) {Phone phone = new Ph....

1.JUC概述

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

相关标签： java

上一篇： 最美的*在路上

下一篇： DOS比较运算符(LSS,LEQ,GTR,GEQ,EQU,NEQ)

推荐阅读