Thread八锁现象问题

1.锁的存在，

synchronized锁的对象方法的调用者，谁先拿到锁，谁就执行，当一个线程在执行的时候，里面有等待，但是另一个线程进不来，所以也得等待，所以谁先拿到锁谁先执行

package com.xjmige.lock8;

import java.util.concurrent.TimeUnit;

//一直都是method1先执行，原因是有锁的存在
public class test1 {
    public static void main(String[] args) {
        Entry1 entry1=new Entry1();
        new Thread(()->{
            entry1.method1();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            entry1.method2();
        },"B").start();
    }
}

class Entry1{
    //synchronized 锁的对象是方法的调用者
    //两个方法是同一个锁，谁先拿到谁执行
    public synchronized void method1(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1执行了");
    }

    public synchronized void method2(){
        System.out.println("method2执行了");
    }
}

2.method1跟method3执行的话，肯定是method3先执行,method3没有加synchronized，所以不受锁的影响

class Entry2{
    //synchronized 锁的对象是方法的调用者
    //两个方法是同一个锁，谁先拿到谁执行
    public synchronized void method1(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1执行了");
    }

    public synchronized void method2(){
        System.out.println("method2执行了");
    }

    public void method3(){
        System.out.println("method3执行了");
    }
}

 3.当有两个对象的时候，分别调用不同对象的方法，会存在两把锁，所以不会同步，谁执行的速度快谁先执行。

public class test3 {
    public static void main(String[] args) {
        Entry3 entry31=new Entry3();
        Entry3 entry32=new Entry3();
        new Thread(()->{
            entry31.method1();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            entry32.method2();
        },"B").start();
    }
}

class Entry3{
    //synchronized 锁的对象是方法的调用者
    //两个方法是同一个锁，谁先拿到谁执行
    public synchronized void method1(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1执行了");
    }

    public synchronized void method2(){
        System.out.println("method2执行了");
    }

    public void method3(){
        System.out.println("method3执行了");
    }
}

 4.静态方法在类加载的时候就存在了，所以用static修饰的方法的锁只有一个，锁的是class文件，普通方法锁的就是对象，所以跟第一条一样，谁先获得锁谁先执行,用两个对象分别来执行，结果也是一样。

public class test4 {
    public static void main(String[] args) {
        Entry4 entry4=new Entry4();
        new Thread(()->{
            entry4.method1();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            entry4.method2();
        },"B").start();
    }
}

class Entry4{
    //synchronized 锁的对象是方法的调用者
    //两个方法是同一个锁，谁先拿到谁执行
    public static synchronized void method1(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1执行了");
    }

    public static synchronized void method2(){
        System.out.println("method2执行了");
    }
}

 

 5.一个static修饰，一个普通方法，同时调用这两个方法，其实这里存在两把锁，一个锁是class的，一个是对象的锁，第一个方法有等待时间，所以method2先执行，无论你用几个对象来执行method1跟method2，都是method2先执行。

public class test5 {
    public static void main(String[] args) {
        Entry5 entry5=new Entry5();
        new Thread(()->{
            entry5.method1();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            entry5.method2();
        },"B").start();
    }
}

class Entry5{
    //synchronized 锁的对象是方法的调用者
    //两个方法是同一个锁，谁先拿到谁执行
    public static synchronized void method1(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1执行了");
    }

    //普通方法，没有static修饰
    public synchronized void method2(){
        System.out.println("method2执行了");
    }
}