8锁问题
如何判断锁的是谁!什么是锁,锁的到底是谁
锁只会锁两个东西:对象、Class
package com.zkw.JUC并发编程.Lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁,就是关于锁的8个问题
* 1、标准情况下,两个线程先打印 发短信 还是 打电话? 先 发短信 在 打电话
* 2、sendSms 延时4秒钟,两个线程先打印 发短信 还是 打电话? 先 发短信 在 打电话
* 解释:synchronized 锁的对象是方法的调用者;两个方法用的是同一个锁,谁先拿到就先执行谁
* main方法里边程序是自上而下执行的
*/
public class Test01 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
},"A").start();
//让其睡眠1s
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"A").start();
}
}
class Phone{
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.zkw.JUC并发编程.Lock8;
import java.awt.*;
import java.util.concurrent.TimeUnit;
/**
* 3、增加一个普通方法后!先执行 发短信 还是 hello? 先 hello 在 发短信
* 解释:因为普通方法不受锁的限制,所以就按照消耗时间的多少先后执行
* 4、两个对象,两个同步方法,发短信 还是 打电话? 先 打电话 在 发短信
* 解释:因为两把锁,那就是按照时间的大小来执行的
*/
public class Test02 {
public static void main(String[] args) {
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
new Thread(()->{
phone1.sendSms();
},"A").start();
//让其睡眠1s
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
/* new Thread(()->{
phone1.hello();
},"B").start();*/
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!!!");
}
}
package com.zkw.JUC并发编程.Lock8;
import java.util.concurrent.TimeUnit;
/**
* 5、增加两个静态的同步方法,只有一个对象 ,先打印 发短信 还是 打电话? 先 发短信 在打电话
* 解释:Phone3 唯一的一个Class 对象;static 是静态方法;类一加载就有了,锁的就是Class模板
*6、两个对象!增加两个静态的同步方法,先打印 发短信?打电话? 先 发短信 在 打电话
* 解释:两个对象的Class类锁只有一个,static 锁的就是Class模板
*/
public class Test03 {
public static void main(String[] args) {
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
new Thread(()->{
phone1.sendSms();
},"A").start();
//让其睡眠1s
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
/* new Thread(()->{
phone1.call();
},"B").start();*/
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("打电话!!!");
}
}
package com.zkw.JUC并发编程.Lock8;
import java.util.concurrent.TimeUnit;
/**
* 7、一个静态同步方法,1个普通同步方法,一个对象,先打印 发短信?打电话? 先 打电话 在 发短信
* 8、一个静态同步方法,1个普通同步方法,、两个对象,先打印 发短信?打电话? 先 打电话 在 发短信
** 解释:static 是静态方法 锁的是Class模板;普通方法 锁的是调用者 锁的对象不一样,就按照消耗时间的大小先后执行
*/
public class Test04 {
public static void main(String[] args) {
Phone4 phone1 = new Phone4();
Phone4 phone2 = new Phone4();
new Thread(()->{
phone1.sendSms();
},"A").start();
//让其睡眠1s
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
/* new Thread(()->{
phone1.call();
},"B").start();*/
new Thread(()->{
phone2.call();
},"B").start();
}
}
//Phone4 唯一的一个Class 对象
class Phone4{
//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("打电话!!!");
}
}
总结:
1、同步静态方法锁的是Clas,故不受创建对象的数量影响。
2、普方法不受锁的影响。