线程八锁

Bertha 。 2021-09-16 03:22 260阅读 0赞

【问题一】

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

输出：

![70][]

分析：创建出的线程1和线程2，锁住的是同一对象n1,  public synchronized void a() 等价于

public void a() \{  
 synchronized(this) \{\}  
\}

而两线程的运行是并行的，也就是运行顺序是随机的，所以运行的结果如上图。

【问题二】

class Number{
        public synchronized void a() {
    	    try { Thread.sleep(1000); } catch (InterruptedException e) {}
            System.out.println(1);
        }
        public synchronized void b() {
            System.out.println(2);
        }
    }
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(()->{ n1.a(); }).start();
        new Thread(()->{ n1.b(); }).start();
    }

输出：

![70][]

分析： 原因同上一题是一样的，不一样之处在于线程1在运行时睡眠了1秒钟，但这并不影响输出顺序。首先电脑随机选出先运行的线程，一旦选定，线程进入owner将被上锁，上锁了之后，无论此线程睡眠多久，都要将它先执行完，再执行另一个线程。

【问题三】

class Number{
        public synchronized void a() {
    	    try { Thread.sleep(1000); } catch (InterruptedException e) {}
            System.out.println(1);
        }
        public synchronized void b() {
            System.out.println(2);
        }
        public void c() {
            System.out.println(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();
    }
    }

输出：

![70 1][]

分析：我们可以看到三个线程为同一对象，其中线程1，线程2上锁，线程3未上锁，所以线程3的完成取决于电脑的随机分配。而且线程1加上了睡眠时间，所以如果线程1和线程3同步运行，则线程3先运行完成。而线程2和线程3谁先运行完成取决于电脑的随机选择。线程1和线程2的先后顺序同上一道题。

【问题四】

class Number {
        public synchronized void a() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println(1);
        }
    
        public synchronized void b() {
            System.out.println(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();
        }
    }

输出：

![70 2][]

分析：这里创建的是两个对象，两个线程分别拥有不同的对象，所以上不上锁其实是无所谓的，但是这里线程1有一个睡眠过程，所以线程2先输出。

【问题五】

class Number {
       
            public synchronized static void a() { //锁住的是 Number.class
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                System.out.println(1);
            }
            public synchronized void b() {//锁住的是n1
                System.out.println(2);
            }
       
        public static void main(String[] args) {
            Number n1 = new Number();
            new Thread(()->{ n1.a(); }).start();
            new Thread(()->{ n1.b(); }).start();
        }
    }

输出：

![70 3][]

分析：道理同上，线程1锁住的对象是Number.class，线程2锁住的对像是n1。public synchronized static void a()等效于：

public static void a() \{  
 synchronized(Number.class) \{ \}  
\}

【问题六】

class Number {
        public synchronized static void a() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println(1);
        }
    
        public synchronized static void b() {
            System.out.println(2);
        }
    
        public static void main(String[] args) {
            Number n1 = new Number();
            new Thread(() -> {
                n1.a();
            }).start();
            new Thread(() -> {
                n1.b();
            }).start();
        }
    }

输出：

![70 4][]

分析：同【问题二】，线程1,2的对象都为Number.class。

【问题七】

class Number {
        public synchronized static void a() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println(1);
        }
    
        public synchronized void b() {
            System.out.println(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();
        }
    }

输出：

![70 5][]

分析：线程1的对象为Number.class,线程2的对象为n2,两个线程同时运行，但是线程1睡眠了1秒钟，所以线程2先输出，再输出线程1的1。

【问题八】

class Number {
        public synchronized static void a() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println(1);
        }
    
        public synchronized static void b() {
            System.out.println(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();
        }
    }

输出：

![70 4][]

分析：锁住的是同一对象Number.class，故先运行那个线程由电脑随机给出。

**日常鸡汤：*****每一个优秀的人，都有一段沉默的时光***

**                 ** ***是那一段时光，不抱怨不诉苦***

**                 ** ***最后渡过了这段感动自己的日子。。。***

[70]: /images/20210811/c33bebd0552a4729adcfbee609ad12f7.png
[70 1]: /images/20210811/ef97f7e4b91147419ed5b6710fa61091.png
[70 2]: /images/20210811/75755e6269754183b7b75bcc02f8ad4c.png
[70 3]: /images/20210811/e5a8802d050e4b7f96fc9bf8b34192a3.png
[70 4]: /images/20210811/05c00db698bd48d8b82a2a054e30de84.png
[70 5]: /images/20210811/f04a1fc6233044e59764d0d051d537ca.png