Java并发基础：线程八锁

class Number{
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

        在成员函数上添加synchronized关键子，相当于锁住this对象，因此上述代码锁住的是同一对象n1，具有互斥性。程序运行结果为：1 2 或 2 1。

class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

        与情况1类似，锁住的也是同一对象，具有互斥性。如果线程1先抢占到CPU，结果为1秒后1 2，如果线程2先抢占到CPU，结果为2 1秒后1。因此，程序运行结果为：1s后1 2 或 2 1s后1。

class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
    new Thread(()->{ n1.c(); }).start();
}

        方法a和方法b上均添加有synchronized关键子，因此锁住的是this对象，具有互斥性，但是方法c没有添加synchronized关键子，因此不会受对象锁的影响。程序运行结果为：3 1s后1 2，或 2 3 1s后1 或3 2 1s后1。

class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

        synchronized关键字添加到成员函数上，锁住的是this对象。但是，程序中有两个不同的Number对象n1和n2,因此锁住的是不同的对象，不具有互斥性。程序运行结果为:2 1s后1。

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");

    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

        synchronized放到静态方法上，锁住的是类对象，放到成员方法上，锁住的是this对象。因此锁住的是不同的对象，不具有互斥性。程序运行结果为:2 1s后1。

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

         synchronized放到静态方法上，锁住的是类对象，而java中类对象在内存中只有一份，因此锁住的是同一对象。程序运行结果为：1S后1 2 或 2 1S后1。

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

        方法a锁住的是类对象，方法b锁住的是this对象。线程1调用n1.a(),锁住的是类对象，而线程2调用的是n2.b()对象，锁住的是n2对象，不具有互斥性。程序运行结果为：2 1S后1。

class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
 
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

        以上代码方法a()和方法b()都是static方法，因此锁住的都是类对象，虽然主程序创建了两个不同的Number对象n1和n2，但是类对象在java内存中只有一份，因此锁住的是同一对象。程序运行结果为：1S后1 2 或2 1S后1。