Java synchronized解析

多线程三大特性：

可见性、原子性、有序性

synchronize的特性：

1、同一时刻只有一个线程访问临界资源

2、其它未获取到锁执行权的线程必须排队等待

3、保证共享资源的原子性、可见性和有序性

4、进入synchronized范围内自动加锁，synchronized作用域外锁自动消除，即使异常也会释放锁

synchronize加锁的方式：

• 对于普通同步方法，锁是当前实例对象。

• 对于静态同步方法，锁是当前类的Class对象。

• 对于同步方法块，锁是Synchonized括号里配置的对象。

通过具体的例子来看一下

首先是普通方法：

 class NoSyncTest {
        public void method1() {
            Log.i("sync", "method 1 start");
            try {
                Log.i("sync", "method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 1 end");
        }

        public void method2() {
            Log.i("sync", "method 2 start");
            try {
                Log.i("sync", "method 2 execute");
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 2 end");
        }
    }

    private void noSyncTest() {
        final NoSyncTest test = new NoSyncTest();

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

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

        thread1.start();
        thread2.start();
    }

这是一个没有任何同步的方法，NoSyncTest这个类有两个方法method1和method2，分别执行睡3s和0.5s的动作，然后再两个线程中分别调用这个类的实例test的两个方法，看一下结果：

可以看到method2和method1同时执行，method2因为sleep的时间短所以先结束。

再看一下普通方法同步：

class MethodSyncTest {
        public synchronized void method1() {
            Log.i("sync", "method 1 start");
            try {
                Log.i("sync", "method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 1 end");
        }

        public synchronized void method2() {
            Log.i("sync", "method 2 start");
            try {
                Log.i("sync", "method 2 execute");
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 2 end");
        }
    }

    private void MethodSyncTest() {
        final MethodSyncTest test = new MethodSyncTest();

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

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

        thread1.start();
        thread2.start();
    

synchronize修饰的method1和method2,其他不变，看一下结果：

method1先执行然后3s之后结束了method2才开始执行。（注意这个地方不能new 不同的对象来调用方法，因为修饰普通方法本质是对对象的同步加锁。）

看一下第三种静态同步方法：

 static class StaticMethodSyncTest {
        public static synchronized void method1() {
            Log.i("sync", "method 1 start");
            try {
                Log.i("sync", "method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 1 end");
        }

        public static synchronized void method2() {
            Log.i("sync", "method 2 start");
            try {
                Log.i("sync", "method 2 execute");
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 2 end");
        }
        public static synchronized void method3() {
            Log.i("sync", "method 3 start");
            try {
                Log.i("sync", "method 3 execute");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Log.i("sync", "method 3 end");
        }
    }

    private void StaticMethodSyncTest() {
        final StaticMethodSyncTest test1 = new StaticMethodSyncTest();
        final StaticMethodSyncTest test2 = new StaticMethodSyncTest();

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

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                test2.method2();
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                StaticMethodSyncTest.method3();
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }

static修饰方法相当于这个方法是类方法，可以直接通过类名.方法名调用。我们在这new出了test1和test2两个对象分别调用method1和method2，以及通过类名.方法名调用method3,看一下结果

method1、method2、method3顺序执行。（同步静态方法的本质是锁的当前类）