针对java同步机制的一个自我总结 附实例

最近遇到一个题目关于java同步机制synchronized的，大概的问题是一个person类里面有一个A方法（对方法加锁）一个B方法（对person.class加锁）,然后同时用2个线程执行分别执行A,B方法会不会冲突.

为此我写了一个实例来验证：

public class Person {

   public synchronized void a(){
        Log.e("test","a test 开始");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("test","a test 结束");
    }

    public void b(){
        synchronized (Person.class){
            Log.e("test","b test 开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.e("test","b test 结束");
        }
    }

}

以下是开启两个线程调用该person类

private class MyThread extends Thread{
        @Override
        public void run() {
            Person person = new Person();
            person.a();
        }
    }
    private class MyThread1 extends Thread{
        @Override
        public void run() {
            Person person = new Person();
            person.b();
        }

    }

 MyThread1 myThread1 = new MyThread1();
 MyThread myThread = new MyThread();
 myThread.start();

 myThread1.start();

输出结果：

05-11 19:20:45.894 15731-15757/com.xinlanwang.myapplication E/test: a test 开始
05-11 19:20:45.894 15731-15758/com.xinlanwang.myapplication E/test: b test 开始
05-11 19:20:46.894 15731-15757/com.xinlanwang.myapplication E/test: a test 结束

05-11 19:20:46.894 15731-15758/com.xinlanwang.myapplication E/test: b test 结束

小结：先借鉴一位同学的总结的知识点，https://blog.csdn.net/xiao__gui/article/details/8188833，

synchronized(this)以及非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码段

synchronized (Person.class)是对Person类添加一个全局锁,相当于锁住了代码段

因此针对上面的问题结合结论说明是不会冲突的，当两个线程分别实例化出两个person对象的时候，会产生以下三种结论：

（1）两个对象执行各自A方法时是不会冲突的（上面方法反证）

（2）当myThread1 执行A方法，myThread 执行B方法的时候也不会冲突（实验证明），只有一个线程占用了B方法，所以不会有冲突

（3）当两个线程同时执行B方法时，会产生冲突，因为B方法已经对person加了全局锁，相当于给person的所有对象共用一个B方法，只有其中一个线程执行结束释放锁之后，其他线程才能使用B方法。以下是实验结果：05-11 19:21:37.424 15858-15875/com.gg.myapplication E/test: b test 开始
05-11 19:21:38.424 15858-15875/com.gg.myapplication E/test: b test 结束
05-11 19:21:38.464 15858-15874/com.gg.myapplication E/test: b test 开始

05-11 19:21:39.474 15858-15874/com.gg.myapplication E/test: b test 结束

扩展：当遇到static修饰的synchronized A方法时，两个线程分别执行A,B方法会冲突吗？

public class Person {

    static synchronized void a(){
        Log.e("test","a test 开始");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.e("test","a test 结束");
    }

    public void b(){
        synchronized (Person.class){
            Log.e("test","b test 开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.e("test","b test 结束");
        }
    }

}

以下是调用的方法

private class MyThread extends Thread{
        @Override
        public void run() {
            Person.a();
        }
    }

    private class MyThread1 extends Thread{
        @Override
        public void run() {
            Person person = new Person();
            person.b();
        }
    }

 MyThread1 myThread1 = new MyThread1();
 MyThread myThread = new MyThread();
 myThread.start();

 myThread1.start();

结果显示：

05-11 17:34:45.894 14490-14502/com.gg.myapplication E/test: a test 开始
05-11 17:34:46.884 14490-14502/com.gg.myapplication E/test: a test 结束
05-11 17:34:46.914 14490-14504/com.gg.myapplication E/test: b test 开始

05-11 17:34:47.914 14490-14504/com.gg.myapplication E/test: b test 结束

得到结论是有会冲突的，因为synchronized 修饰静态方法的时候，等同于给该类的所有对象都加了一把同步锁，因为静态方法属于类，不属于对象。

以上是自己的实验总结 感谢之前同学的总结，省了很多时间