验证一个线程执行对象的synchronized同步方法，另一个线程不能访问该对象的synchronized方法

1.情况一：一个线程执行对象的的同步方法，另一个线程能访问该对象的非同步方法

   Student对象类，分别有同步方法getStuName()和非同步方法getStuAge() 

package com.alibaba.nacos.example;

/**
 * @Author xiucai
 * @Description
 * @Date 2019/6/27 13:27
 **/

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private int score;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public synchronized String getStuName(){
        try {
            System.out.println("获取名字开始==");
            Thread.sleep(3000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            System.out.println("获取名字结束==");
        }
        return  name;
    }

    public  int getStuAge(){
        try {
            System.out.println("获取年龄开始");
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            System.out.println("获取年龄结束");
        }
        return age;
    }

    @Override
    public int compareTo(Student o) {
        if(this.score>o.score){
            return 1;
        }else if(this.score<o.score){
            return -1;
        }else if(this.age>o.age){
            return 1;
        }else if(this.age<o.age){
            return -1;
        }else {
            return 0;
        }
    }
}

测试类：MainTest类

package com.alibaba.nacos.example;


/**
 * @Author xiucai
 * @Description
 * @Date 2019/6/27 13:28
 **/
public class MainTest {
    public static void main(String[] args) {
        Student stu = new Student("小明",1);
        Thread1 t1 = new Thread1(stu);
        Thread2 t2 = new Thread2(stu);
        Thread th1 = new Thread(t1);
        Thread th2 = new Thread(t2);
        th1.start();
        th2.start();

    }

    static class Thread1 extends Thread{
        private Student student;

        public Thread1 (Student student){
            this.student = student;
        }
        @Override
        public void run(){
            student.getStuName();
        }

    }

    static class Thread2 extends Thread{
        private Student student;

        public Thread2 (Student student){
            this.student = student;
        }
        @Override
        public void run(){
            student.getStuAge();
        }

    }
}

情况一运行结果：获取年龄和获取名字交替出现，情况一验证。

2.情况二：一个线程访问一个对象的synchronized同步方法，另一个线程不能访问该对象的所有synchronized方法

代码：在情况一的基础上稍作改动即可，即把getStuAge改为synchronized方法。

运行结果如下：不管运行多少次，都是顺序执行，不会交替打印名字和年龄。结果得以验证

分享结束~~~~~喜欢钓鱼的程序猿们可以关注我的公众号哦！