8锁现象
如何判断锁的是谁!永远的知道什么是锁,锁到底锁的是谁?????
深刻理解我们的锁
1、synchronized 锁的对象是方法的调用者!多个方法用的是同一个锁,谁先拿到谁执行!
2、增加了一个普通方法后!普通方法不受锁的影响,所以会先走普通方法!
3、两个对象,两个同步方法,则有两个方法的调用者,所以是有两把锁!
4、增加两个静态的同步方法,只有一个对象。static 静态方法 ,类一加载就有了!锁的是Class,全局唯一;
5、两个对象!增加两个静态的同步方法,锁的是Class,全局唯一,还是一把锁,所以依旧需要互相等待;
6、1个静态的同步方法,1个普通的同步方法,一个对象;
静态的同步方法 锁的是 Class 类模板;普通的同步方法 锁的调用者;所以是两把锁,不需要相互等待;
7、1个静态的同步方法,1个普通的同步方法 ,两个对象;同6一样是两把锁,不需要互相等待;
下面我们就通过代码来验证这几种情况:
第1,2两种情况的代码
1、synchronized 锁的对象是方法的调用者!多个方法用的是同一个锁,谁先拿到谁执行!
2、增加了一个普通方法后!普通方法不受锁的影响,所以会先走普通方法!
/**
* 8锁,就是关于锁的8个问题
* 1、标准情况下,两个线程先打印 发短信还是 打电话? 1/发短信 2/打电话
* 2、sendSms延迟4秒,两个线程先打印 发短信还是 打电话? 1/发短信 2/打电话
* 答案:为先发短信后打电话
* 原因:synchronized 锁的存在,只有一把锁,谁先拿到,谁就先执行
*/
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();
phone.hello();
}
}
class Phone{
// 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");
}
}
第3,4种情况代码
3、两个对象,两个同步方法,则有两个方法的调用者,所以是有两把锁!
4、增加两个静态的同步方法,只有一个对象。static 静态方法 ,类一加载就有了!锁的是Class,全局唯一;
package com.zgq.lock8;
import java.util.concurrent.TimeUnit;
/**
* 3、 增加了一个普通方法后!先执行发短信还是Hello? 普通方法
* 答案:先hello后发短信
* 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(()->{
//phone1.hello();
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");
}
}
第5,6种情况下的代码
5、两个对象!增加两个静态的同步方法,锁的是Class,全局唯一,还是一把锁,所以依旧需要互相等待;
6、1个静态的同步方法,1个普通的同步方法,一个对象;
静态的同步方法 锁的是 Class 类模板;普通的同步方法 锁的调用者;所以是两把锁,不需要相互等待;
package com.zgq.lock8;
import java.util.concurrent.TimeUnit;
/**
* 5、增加两个静态的同步方法,只有一个对象,先打印 发短信?打电话?
* 答案:先发短信后打电话
* 6、两个对象!增加两个静态的同步方法, 先打印 发短信?打电话?
* 答案:先发短信后打电话
*/
public class Test3 {
public static void main(String[] args) {
// 两个对象的Class类模板只有一个,static,锁的是Class
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
// 捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
//phone1.call();
phone2.call();
},"B").start();
}
}
/**
* Phone3唯一的一个 Class 对象,全局唯一:
* Class<Phone3> phone3Class = Phone3.class;
* static 静态方法 ,类一加载就有了!锁的是Class
* 所以此处两种方法用的是同一把锁
*/
class Phone3{
// synchronized 锁的对象是方法的调用者!、
// 两个方法用的是同一个锁,谁先拿到谁执行!
//
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
Class<Phone3> phone3Class = Phone3.class;
}
public static synchronized void call(){
System.out.println("打电话");
}
}
第7,8种情况下的代码
7、1个静态的同步方法,1个普通的同步方法 ,两个对象;同6一样是两把锁,不需要互相等待;
/**
* 7、1个静态的同步方法,1个普通的同步方法 ,一个对象,先打印 发短信?打电话?
* 答案:先打电话后发短信
* 8、1个静态的同步方法,1个普通的同步方法 ,两个对象,先打印 发短信?打电话?
* 答案:先打电话后发短信
*/
public class Test4 {
public static void main(String[] args) {
// 两个对象的Class类模板只有一个,static,锁的是Class
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(()->{
//phone1.call();
phone2.call();
},"B").start();
}
}
/**
* Phone4唯一的一个 Class 对象,全局唯一:
* Class<Phone3> phone3Class = Phone3.class;
* static 静态方法 ,类一加载就有了!锁的是Class
* 两个方法不是同一个锁,所以不需要互相等待
*/
class Phone4{
// 静态的同步方法 锁的是 Class 类模板
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
Class<Phone3> phone3Class = Phone3.class;
}
// 普通的同步方法 锁的调用者
public synchronized void call(){
System.out.println("打电话");
}
}
大家细细体会这八种情况下,锁的对象的变化,希望大家都能有所收获!!!希望我的文章可以帮助到大家。