JUC之八锁现象理解锁
程序员文章站
2022-03-10 16:12:04
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概述
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
上一篇: 静态路由
下一篇: Vue中DOM操作+过渡效果