한 라인이 한 대상에 들어가는synchronized 방법이 있으면 다른 라인이 이 대상에 들어갈 수 있는 방법이 있습니까?

한 라인이 한 대상에 들어가는synchronized 방법이 있으면 다른 라인이 이 대상에 들어갈 수 있는 방법이 있습니까?

먼저 결론: 상황1: 한 라인이 한 대상의synchronized 방법을 방문할 때 다른 라인은 이 대상의 비동기적인 방법을 동시에 방문할 수 있다.상황2: 한 라인이 한 대상의synchronized 방법에 접근할 때 다른 라인은 이 대상의 일반적인 동기화 방법을 동시에 접근할 수 없습니다.
상황3: 한 라인이 한 대상의synchronized 방법에 접근할 때 다른 라인은 이 대상에 동시에 접근할 수 있는 정적 동기화 방법, 즉staticsynchronized 수식 방법이다.
상황4: 한 라인이 한 대상의 static synchronized 방법에 접근할 때 다른 라인은 이 대상에 동시에 접근할 수 없는 정적 동기화 방법, 즉static synchronized 수식 방법입니다.
상황4static로 수식된 동기화 방법으로 추가된 자물쇠는 클래스 자물쇠로 전역적으로 공유되는 유일한 자물쇠이다. 한 라인이 이 유일한 자물쇠를 사용하면 다른 라인은 당연히 이 자물쇠를 사용할 수 없다.
확인

import java.util.Scanner;

/**
 * TODO
 *
 * @author lhz
 * @date 2020/03/19
 */
public class Main5 {
    public static void main(String[] args) {
       TestSync testSync = new TestSync();

        Thread thread0 = new Thread(new Runnable() {
            @Override
            public void run() {
                testSync.run0();
            }
        });

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testSync.run1();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testSync.run2();
            }
        });

        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                testSync.run3();
            }
        });

        Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                TestSync.run4();
            }
        });

        Thread thread5 = new Thread(new Runnable() {
            @Override
            public void run() {
                TestSync.run5();
            }
        });

        Thread thread6 = new Thread(new Runnable() {
            @Override
            public void run() {
                TestSync.run6();
            }
        });

      //  thread0.start();
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
        thread6.start();

    }
}
class TestSync {
    synchronized void run0() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" synchronized 0...run0...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    synchronized void run1() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" synchronized ...run1...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    synchronized void run2() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" synchronized ...run2...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    void run3() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" ...run3...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static void run4() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" static ...run4...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static synchronized void run5() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" static synchronized  ...run5...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static synchronized void run6() {
        for (int i = 0; i < 5; i++) {
            System.out.println(" static synchronized  ...run6...
");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}