java之Synchronized(锁住对象和锁住代码)

1、问题

Synchronized我们一般都知道是锁，但是我们怎么区分是锁对象还是锁代码呢？

2、测试Demo

    package leetcode.chenyu.test;
     
    public class Synchronized {
       
         class Test {
            public synchronized  void testFirst() {
                print("testFirst");
            }
           
            public void testSecond() {
                synchronized(this) {
                    print("testSecond");
                }
            }
           
            public void testThird() {
                synchronized(Test.class) {
                    print("testThird");
                }
            }
           
            public  void print(String method) {
                System.out.println(method + "start");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(method + "end");
            }
        }
           
        class TestThread extends Thread {
           
            public int mType = 0;
            public Test mTest = null;
           
            public TestThread(int type, Test test) {
                this.mType = type;
                this.mTest = test;
            }
           
            public void run() {
                if (mTest == null) {
                    if (mType == 1) {
                        Test test = new Test();
                        test.testFirst();
                    }
                    else if (mType == 2) {
                        Test test = new Test();
                        test.testSecond();
                    }
                    else if (mType == 3) {
                        Test test = new Test();
                        test.testThird();
                    }
                } else {
                    if (mType == 1) {
                        mTest.testFirst();
                    }
                    else if (mType == 2) {
                        mTest.testSecond();
                    }
                    else if (mType == 3) {
                        mTest.testThird();
                    }
                }
            }
        }
       
        public static void main(String[] args) {
            Synchronized syn = new Synchronized();
            Test test = syn.new Test();
                for (int i = 0; i < 5; ++i) {
                    syn.new TestThread(1, null).start();
            }
        }
    }

 
3、运行结果和分析


1）、按照上面的运行结果

    testFirststart
    testFirststart
    testFirststart
    testFirststart
    testFirststart
    testFirstend
    testFirstend
    testFirstend
    testFirstend
    testFirstend


2）、把for循环里面的代码换如下

syn.new TestThread(2, null).start();

运行结果如下

    testSecondstart
    testSecondstart
    testSecondstart
    testSecondstart
    testSecondstart
    testSecondend
    testSecondend
    testSecondend
    testSecondend
    testSecondend

对于上面1）、2）、两种情况，synchronized(this)以及非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码段，锁的是对象，也就是锁的本身this, 由于每个线程都新构建了一个新的对象，所以加了synchronized没有锁住。

3)、把for循环里面的代码换如下

syn.new TestThread(1, test).start();

syn.new TestThread(2, test).start();

运行结果都一样如下

    testSecondstart
    testSecondend
    testSecondstart
    testSecondend
    testSecondstart
    testSecondend
    testSecondstart
    testSecondend
    testSecondstart
    testSecondend

这里由于我们几个现场都共用一个对象，所以对象固定了，所以就锁住了，其它线程在没有释放锁的时候，进不来。

4)、把for循环里面的代码换如下

syn.new TestThread(3, null).start();

syn.new TestThread(3, test).start();

结果都如下

    testThirdstart
    testThirdend
    testThirdstart
    testThirdend
    testThirdstart
    testThirdend
    testThirdstart
    testThirdend
    testThirdstart
    testThirdend

synchronized(Test.class)实现了全局锁的效果，不管对象是不是一样的，都是同样的效果，就锁住代码了


我么一般用这个比较多。

 
4、总结

1、synchronized加在非静态方法前和synchronized(this)都是锁住了这个类的对象，如果多线程访问，对象不同，就锁不住，对象固定是一个，就可锁住。

2、synchronized(类名.class)和加在静态方法前，是锁住了代码块，不管多线程访问的时候对象是不是同一个，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步，缩小锁的粒度。


4、总结

作者：chen.yu
深信服三年半工作经验，目前就职游戏厂商，希望能和大家交流和学习,
微信公众号：编程入门到秃头 或扫描下面二维码
零基础入门进阶人工智能(链接)