V. 8 lock phenomenon
package com.xizi.lock8;
import java.util.concurrent.TimeUnit;
/**
* 1.标准情况下,两个线程先打印发短信还是打电话? 发短信
* 2.SendSms延迟4秒,两个线程先打印发短信还是打电话? 发短信
*/
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{
//synchronied 锁的对象是方法的调用者
//两个方法用的是同一个锁,谁先拿到调用谁执行
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.xizi.lock8;
import java.util.concurrent.TimeUnit;
/*
3.增加一个普通方法后,先执行发短信还是Hello? 普通方法hello(不受锁的影响)
4.两个对象,两个同步方法,发短信还是打电话? 打电话(发短信延迟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();
// new Thread(()->{
// phone.hello();
// },"C").start();
}
}
class Phone2{
//synchronied 锁的对象是方法的调用者
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");
}
}
package com.xizi.lock8;
import java.util.concurrent.TimeUnit;
/*
5.增加两个静态的同步方法,只有一个对象,先打印发短信还是打电话? 发短信
//static 静态方法
//类一加载就有了,锁的是Class
谁调用先执行谁
*/
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.call();
},"B").start();
}
}
class Phone3{
//synchronied 锁的对象是方法的调用者
//两个方法用的是同一个锁,谁先拿到谁执行
//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("打电话");
}
}
package com.xizi.lock8;
import java.util.concurrent.TimeUnit;
/*
6.1个静态的同步方法 ,1个普通的同步方法,一个对象,先打印发短信还是打电话? 打电话(发短信延迟4秒,
synchronied 锁的对象是方法的调用者 static synchronized 锁的是Class 类模板)
7.1个静态的同步方法 ,1个普通的同步方法,两个对象,先打印发短信还是打电话? 打电话
*/
public class Test4 {
public static void main(String[] args) {
Phone4 phone1 = new Phone4();
Phone4 phone2 = new Phone4();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
//延迟1秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
class Phone4{
//synchronied 锁的对象是方法的调用者
//static 静态方法
//类一加载就有了,锁的是Class 类模板
public static synchronized void sendSms(){
try {
//延迟4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
//普通的同步方法 锁的调用者
public synchronized void call(){
System.out.println("打电话");
}
}
to sum up
new this specific mobile phone
The only template for static Class