接下来以代码为例来理解锁的八种情况:
TimeUtils工具类:API提供的常用工具类,时间处理。
1、以下代码是先发短信还是先打电话?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
}).start();
}
}
class Phone{
public synchronized void sendSms(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
这时候是先发短信还是先打电话?
答案是先发短信, 但是我们要记住,这里不是因为hone.sendSms()先执行,而是锁的原因。
2、以下代码是先发短信还是先打电话?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
}).start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
答案依然是先发信息再打电话。
以上两个问题说明了不是因为执行的顺序原因而是锁的问题。
为什么是发短信先执行呢?原因是Synchrinized锁的对象是方法的调用者,这里是phone,两个方式使用的是同一把锁,谁先拿到就会谁来使用,发短信的方法先拿到锁,所以先进行发短信。
问题3:增加一个普通方法并调用,是先打印发短信还是打印hello?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.hello();
}).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("打电话");
}
public void hello(){
System.out.println("Hello");
}
}
先看结果:
为什么呢?原因是因为hello方法不是同步方法,不受锁的影响。
问题4:两个对象,两个同步方法,打印结果是什么样的?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
}).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("打电话");
}
public void hello(){
System.out.println("Hello");
}
}
结果:
两个锁对象判断谁先执行是根据对象调用的时间。
问题5:同步方法是静态方法一下代码打印的结果是?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
}).start();
}
}
class Phone{
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("打电话");
}
}
结果:
这里的原因是static修饰的同步方法在类加载的时候就存在了,锁的对象是Class,发短信先把调用。
问题6:两个对象调用两个静态同步方法,以下代码的结果?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
}).start();
}
}
class Phone{
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("打电话");
}
}
看结果:
为什么呢?原因还是因为这时候的锁对象还是Class对象,Phone和Phone2对象的Class是一样的,所以在调用的时候先打印发短信。
问题7:一个静态同步方法,一个普通方法,一个对象,一下代码的结果是?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
}).start();
}
}
class Phone{
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("打电话");
}
}
看结果:
解析:这时候锁的对象是两个,一个是Class模板,一个是Phone。属于两把锁,不需要相互去等待,完全可以去根据时间来看结果。
问题8:两个对象,一个静态同步方法一个普通同步方法,以下代码的结果?
package com.yy;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone.sendSms();
}).start();
try {
TimeUnit.SECONDS.sleep(1); //TimeUtil工具类提供睡眠时间
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
}).start();
}
}
class Phone{
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("打电话");
}
}
结果:
原因还是因为程序中存在两把锁,锁的对象有两个,一个是Class模板,一个是Phone2。锁的对象不同,相互之间不需要等待。
总结:通过以上内容我们可以知道static锁的是this的Class模板,而普通的同步方法锁的是方法调用者,如果存在两把锁,调用之间是不冲突的。