关于synchronized的一点测试

@Test
    public void doTest01() {
        final InnerObject innerObj = new InnerObject();
        System.out.println("synchronized 关键字使用 \n" + "--------------------------");
        Thread t03A = new Thread(new Runnable() {
            @Override
            public void run() {
                outerMethod01(innerObj);
            }
        }, "A");
        Thread t03B = new Thread(new Runnable() {
            @Override
            public void run() {
                outerMethod02(innerObj);
            }
        }, "B");
        t03A.start();
        t03B.start();
    }

    class InnerObject {
        private void innerMethod01() {
            int i = 0;
            while (i++ < 3) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
//                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        private void innerMethod02() {
            int j = 0;
            while (j++ < 3) {
                System.out.println(Thread.currentThread().getName() + ":" + j);
                try {
//                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 外部类方法1
     */
    private void outerMethod01(InnerObject innerObj) {
        synchronized (innerObj) {
            innerObj.innerMethod01();
        }
    }

    /**
     * 外部类方法2
     */
    private void outerMethod02(InnerObject innerObj) {
//        synchronized (innerObj) {
//            innerObj.innerMethod02();
//        }
        innerObj.innerMethod02();
    }

• • 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
  • 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
  • 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
  • 四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

上面是测试 synchronized 的代码，如果 outerMethod02 中不使用 synchronized，那么输出结果是随机的，因为t03A加上锁，但t03B没有加锁，两者都是异步，虽然都是1，2，3输出，但互斥的只是 outerMethod01 中输入的 innerObj 变量，InnerObject 类并没有互斥，所以在 t03A 调用 InnerObject  中的 innerMethod01时，t03B还是可以调用 InnerObject  中的 innerMethod02，所以结果随机无法确定。

如

A:1
B:1
B:2
B:3
A:2
A:3

 

但把 外部类方法2 改成

    private void outerMethod02(InnerObject innerObj) {
        synchronized (innerObj) {
            innerObj.innerMethod02();
        }
//        innerObj.innerMethod02();
    }

其结果只有两种

--------------------------
A:1
A:2
A:3
B:1
B:2
B:3

及

B:1
B:2
B:3
A:1
A:2
A:3

• 1.synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
• 2.synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

第一种结果出现次数为多，可以理解为 synchronized 锁了 InnerObject 对象，所以哪个线程先开始调用对象中的方法，后面一个线程就要暂时停止，代码中是 t03A 在前，所以第一种结果出现的机会较高。

 

 

 

 

private void test() {
    final TestSynchronized test1 = new TestSynchronized();
    final TestSynchronized test2 = new TestSynchronized();
    Thread t1 = new Thread(new Runnable() {

        @Override
        public void run() {
            test1.method01("a");
            //test1.method02("a");
        }
    });
    Thread t2 = new Thread(new Runnable() {

        @Override
        public void run() {
            test2.method01("b");
            //test2.method02("a");
        }
    });
    t1.start();
    t2.start();
}

private static class TestSynchronized{
    private int num1;
    public synchronized void method01(String arg) {
        try {
            if("a".equals(arg)){
                num1 = 100;
                System.out.println("tag a set number over");
                Thread.sleep(1000);
            }else{
                num1 = 200;
                System.out.println("tag b set number over");
            }
            System.out.println("tag = "+ arg + ";num ="+ num1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static int  num2;
    public static synchronized void method02(String arg) {
        try {
            if("a".equals(arg)){
                num2 = 100;
                System.out.println("tag a set number over");
                Thread.sleep(1000);
            }else{
                num2 = 200;
                System.out.println("tag b set number over");
            }
            System.out.println("tag = "+ arg + ";num ="+ num2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//调用method01方法打印日志【普通方法】
tag a set number over
tag b set number over
tag = b;num =200
tag = a;num =100


//调用method02方法打印日志【static静态方法】
tag a set number over
tag = a;num =100
tag b set number over
tag = b;num =200

• 在static方法前加synchronized：静态方法属于类方法，它属于这个类，获取到的锁，是属于类的锁。
• 在普通方法前加synchronized：非static方法获取到的锁，是属于当前对象的锁。
• 结论：类锁和对象锁不同，synchronized修饰不加static的方法，锁是加在单个对象上，不同的对象没有竞争关系；修饰加了static的方法，锁是加载类上，这个类所有的对象竞争一把锁。

第一个结果，是因为锁加在对象上，两个线程对应两个对象，没对应一把锁，所以出现平行执行的现象。

第二个结果，是因为锁加在类上，两个对应同一个类，所以哪个线程先执行，后面一个线程就要等着。