首页 🔴 Java

场景一

import java.util.concurrent.TimeUnit;
/*
* 标准情况下 是先执行A方法 还是先执行B方法?
* 答案:先执行A方法
* 解释:被 synchronized 修饰的方式, 锁的对象是方法的调用者
* 所以说这里两个方法调用的对象是同一个, 先调用的先执行!
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(test::A, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(test::B, "B").start();
    }
}
class Test {
    public synchronized void A() {
        System.out.println("执行了A方法!");
    }
    public synchronized void B() {
        System.out.println("执行了B方法!");
    }
}

场景二

import java.util.concurrent.TimeUnit;

/*
* A方法休眠三秒后 是先执行A方法 还是先执行B方法
* 答案:先执行A方法
* 解释:被 synchronized 修饰的方式,锁的对象是方法的调用者
* 所以说这里两个方法调用的对象是同一个,先调用的先执行!
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(test::A, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(test::B, "B").start();
    }
}
class Test {
    public synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public synchronized void B() {
        System.out.println("执行了B方法!");
    }
}

场景三

import java.util.concurrent.TimeUnit;
/*
* A方法休眠三秒后 是先执行A方法 还是先执行B方法
* 答案:先执行B方法
* 解释:这里的B方法没有 synchronized 的修饰
* 所以其不受锁的影响
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(test::A, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(test::B, "B").start();
    }
}
class Test {
    public synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public void B() {
        System.out.println("执行了B方法!");
    }
}

场景四

import java.util.concurrent.TimeUnit;
/*
* 两个对象 是先执行A方法 还是先执行B方法
* 答案:先执行B方法
* 解释:被锁的调用者不是同一个对象
* 所以谁先休眠结束谁先执行
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test1 = new Test();
        Test test2 = new Test();
        new Thread(test1::A, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(test2::B, "B").start();
    }
}
class Test {
    public synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public synchronized void B() {
        System.out.println("执行了B方法!");
    }
}

场景五

import java.util.concurrent.TimeUnit;
/*
* 两个静态同步方法一个对象 是先执行A方法 还是先执行B方法
* 答案:先执行A方法
* 解释:因为是静态方法, 所以被锁的调用者是这个Test类
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(()->{test.A();}, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{test.B();}, "B").start();
    }
}
class Test {
    public static synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public static synchronized void B() {
        System.out.println("执行了B方法!");
    }
}

场景六

import java.util.concurrent.TimeUnit;
/*
* 两个静态同步方法两个对象 是先执行A方法 还是先执行B方法
* 答案:先执行A方法
* 解释:因为是静态方法, 所以被锁的调用者是这个Test类
* 不管是几个对象, 都是调用的同一个类里面的方法
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test1 = new Test();
        Test test2 = new Test();
        new Thread(()->{test1.A();}, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{test2.B();}, "B").start();
    }
}
class Test {
    public static synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public static synchronized void B() {
        System.out.println("执行了B方法!");
    }
}

场景七

import java.util.concurrent.TimeUnit;
/*
* 一个对象 一个静态方法一个普通方法 是先执行A方法 还是先执行B方法
* 答案:先执行B方法
* 解释:被锁的不是同一个调用者
* 一个被锁的是类, 一个被锁的是对象
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(()->{test.A();}, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{test.B();}, "B").start();
    }
}
class Test {
    public static synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public synchronized void B() {
        System.out.println("执行了B方法!");
    }
}

场景八

import java.util.concurrent.TimeUnit;
/*
* 两个对象 一个静态方法一个普通方法 是先执行A方法 还是先执行B方法
* 答案:先执行B方法
* 解释:被锁的不是同一个调用者
* 一个被锁的是类, 一个被锁的是对象
*/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Test test1 = new Test();
        Test test2 = new Test();
        new Thread(()->{test1.A();}, "A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{test1.B();}, "B").start();
    }
}
class Test {
    public static synchronized void A() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行了A方法!");
    }
    public synchronized void B() {
        System.out.println("执行了B方法!");
    }
}



文章评论