如何判断锁的是什么？
首先我们先来看下面的代码。思考下面两个问题。
/**
* 1.Q:下面程序执行后，是先打印 “看电影” 还是 “玩游戏” 呢？ A:先打印“看电影”
* 2.Q:若watchMovie方法延迟4秒，是先打印 “看电影” 还是 “玩游戏” 呢？ A:先打印“看电影” */
public class Test01 {
public static void main(String[] args){
TV tv = new TV();
new Thread(()->{
tv.watchMovie();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
tv.playGame();
},"B").start();
}
}
class TV{
public synchronized void watchMovie(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("看电影");
}
public synchronized void playGame(){
System.out.println("打游戏");
}
}
synchronized 锁的对象是方法的调用者！
就上面代码而言，看电影和玩游戏两个方法是用的TV对象的一把锁，所以谁先拿到谁先执行！
我们在思考下面两个问题。
/**
* 3.Q:增加了一个普通方法后，是先打印 “开机” 还是 “看电影” 呢？ A:先打印“开机”
* 4.Q:若两个对象，两个同步方法，是先打印 “看电影” 还是 “打游戏” 呢？ A:先打印“打游戏” */
public class Test02 {
public static void main(String[] args){
TV2 tv1 = new TV2();
TV2 tv2= new TV2();
new Thread(()->{
tv1.watchMovie();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
tv2.playGame();
},"B").start();
}
}
class TV2{
public synchronized void watchMovie(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("看电影");
}
public synchronized void playGame(){
System.out.println("打游戏");
}
public void open(){
System.out.println("开机");
}
}
就问题3而言，我们之前了解过synchronized 锁的对象是方法的调用者！而普通方法没有synchronized修饰，不受锁控制，所以先执行。
就问题4而言，两个对象，就是两个调用者，也就意味着有两把锁，所以要受时间延迟影响，先打印“打游戏”！
好的，那我们再看下面两组问题：
/**
* 5.Q:增加两个静态方法，只有一个对象，是先打印 “看电影” 还是 “玩游戏” 呢？ A:先打印“看电影”
* 6.Q:若两个对象，两个静态方法，是先打印 “看电影” 还是 “玩游戏” 呢？ A:先打印“看电影” */
public class Test03 {
public static void main(String[] args){
TV3 tv1 = new TV3();
TV3 tv2 = new TV3();
new Thread(()->{
tv1.watchMovie();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
tv2.playGame();
},"B").start();
}
}
class TV3{
public static synchronized void watchMovie(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("看电影");
}
public static synchronized void playGame(){
System.out.println("打游戏");
}
}
static 静态，全局唯一，static 方法在类加载的时候就存在了，synchronized 锁static 方法本质是锁TV对象的Class模板，类的Class模板只有一个，换而言之，调用者只有一个，锁只有一把，所以还是谁先拿到谁先执行！
最后再来看下面两个问题：
/**
* 7.Q:增加1个静态 synchronized 方法，1个普通 synchronized 方法，只有一个对象，是先打印 “看电影” 还是 “打游戏” 呢？ A:先打印“打游戏”
* 8.Q:增加1个静态 synchronized 方法，1个普通 synchronized 方法，两个对象，是先打印 “看电影” 还是 “打游戏” 呢？ A:先打印“打游戏” */
public class Test04 {
public static void main(String[] args){
TV4 tv1 = new TV4();
TV4 tv2 = new TV4();
new Thread(()->{
tv1.watchMovie();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
tv2.playGame();
},"B").start();
}
}
class TV4{
public static synchronized void watchMovie(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("看电影");
}
public synchronized void playGame(){
System.out.println("打游戏");
}
}
就问题7而言，静态synchronized方法和普通synchronized锁的调用者不是一个，前者是类的Class模板，后者是对象，所以有两个调用者，也就存在两把锁，因此，时间延迟的原因占主导。同理问题8也是如此，两个调用者两把锁！
总结：关键理解锁的对象是方法的调用者！锁的对象无外乎两种，一种是new的对象，而一种就是Class模板。要分清具体情况下究竟锁的是什么？
