Synchronized

参考：https://blog.csdn.net/luoweifu/article/details/46613015

1.synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 
（1） 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 
（2）修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 
（3）修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 
（4）修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

2.修饰代码块

package com.ysl.rxjava.SyncThread;

public class SyncThread implements Runnable {
    private static int count;

    public SyncThread() {
        count = 0;
    }

    @Override
    public  void run() {
        synchronized(this) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
		SyncThread s = new SyncThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);

        t1.start();
        t2.start();
    }
}

输出结果：

当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

我们修改一下调用：

public static void main(String[] args) {
        SyncThread s1 = new SyncThread();
        SyncThread s2 = new SyncThread();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s2);

        t1.start();
        t2.start();
    }

再来看结果：

可以看到线程1和线程2同时进行了，这是因为他们操作的是两个完全不同的对象。所以，

synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联，这时会有两把锁分别锁定syncThread1对象和syncThread2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

代码块中  synchronized(。。。) ：

当填写this时，写成synchronized(this) { }：代表使用类生成的对象作为锁；同以对象时阻塞，不同对象时各自可以同时执行。

当填写SyncThread.class时,写成synchronized(SyncThread.class) { }：代表使用类的字节码作为锁；所以对象公用一个锁，线程会阻塞。

当在此类中new一个锁对象呢，private bject object = new Object();

写成synchronized(object) { }：这种情况和this是一样的结果，因为在new不同的对象时，锁object也会被new出来。

当在此类中有一个静态的锁对象呢，private static bject object = new Object();

写成synchronized(object) { }：这种情况和SyncThread.class是一样的结果，因为在new不同的对象时，锁object是静态的，属于类的，不会被new出来。所有的线程都会公用这个静态对象。使用同一把锁。

2.修饰普通方法：

Synchronized作用于整个方法的写法。 
写法一：

public synchronized void method()
{
   // todo
}

写法二：

public void method()
{
   synchronized(this) {
      // todo
   }
}

写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。

package com.ysl.rxjava.SyncThread;

public class SyncThread2 {

    private static int count;

    public synchronized void test1(){
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void test2() {
        synchronized(this) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
public static synchronized void test3(){
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void test4() {
        synchronized(SyncThread2.class) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

下面来调用做对比：

（1）test1修饰方法和test2修改代码块一样

public static void main(String[] args) {
        SyncThread2 syncThread2 = new SyncThread2();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                syncThread2.test2();
//                new SyncThread2().test1();
            }
        }, "A");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                syncThread2.test2();
//                new SyncThread2().test1();
            }
        }, "B");

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

运行结果和上面的第一种情况是一样的；同一个对象的时候，线程是阻塞的，其中一个执行完了才能执行另一个线程。当使用new的方式，取不同对象时，不受影响，可以并行执行。

（2）代码块中使用类名.class来作为同步锁对象

public static void main(String[] args) {
        SyncThread2 syncThread2 = new SyncThread2();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
//                syncThread2.test4();
                new SyncThread2().test4();
            }
        }, "A");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
//                syncThread2.test4();
                new SyncThread2().test4();
            }
        }, "B");

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

上面两种方式的输出结果是一样的：

可以看到执行时两个线程是会安照一定顺序来进行的。这是由于test4的锁对象是个class，而在Java中只会生成一个class文件，也就是锁对象是唯一的。那么当一个线程拿到这个class锁对象执行任务时，另一个线程因为获取不到锁对象只能在那等着。只有前一个执行完成，释放了锁，另一个线程才能拿到这个锁去执行自己的任务。

3.修饰静态方法：

接着使用上面的类，改变调用方法test3：

public static void main(String[] args) {
        SyncThread2 syncThread2 = new SyncThread2();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
//                syncThread2.test3();
                new SyncThread2().test3();
            }
        }, "A");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
//                syncThread2.test3();
                new SyncThread2().test3();
            }
        }, "B");

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

结果和上面的使用class作为锁的结果是一样的。

可以看到：当使用static修饰以后；不管是使用同一个对象还是new的两个完全不同的对象。他们同样会阻塞另一个线程。直到前一个线程的任务执行完。其实静态方法是属于类的，和class是一样的。

此外，一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

总结：

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。 
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。