浅析关键字synchronized

volatile
    只能保证内存可见性（线程A对volatile变量的操作，线程B可见），但无法保证复合操作的原子性（线程A和线程B同时对volatile变量做操作，无法保证原子性）
 

synchronized
主要有4种加锁方式：
    1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
    2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
    3. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；因为Class数据存在于永久代，因此静态方法锁相当于该类的一个全局锁；
    4. 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

1-1. 多个线程访问 同一对象 的同步代码块

/*
    线程对象，需要同步的对象为Count
*/
public class ThreadSyn implements Runnable {
    private volatile static Integer Count = 0;

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

/*
    场景类
    其中线程thread1和thread2访问的其实是相同的对象(threadSyn)
    synchronized锁定的是被其修饰的对象，所以两个线程会产生互斥
    只有当一个同步代码块执行结束后，锁释放了，其他线程才有"机会"竞争到该锁
*/
public class TestSynchronized {
    public static void main(String[] args) {
        ThreadSyn threadSyn = new ThreadSyn();
        Thread thread1 = new Thread(threadSyn, "ThreadSynOne");
        Thread thread2 = new Thread(threadSyn, "ThreadSynTwo");
        thread1.start();
        thread2.start();
    }
}

1-2. 多个线程访问 不同对象 的同步代码块

/*
    修改后的场景类
    其中线程thread1和thread2访问的其实是两个不同的对象(threadSyn,threadSyn2)
    synchronized锁定的是不同的对象，所以两个线程不会产生互斥
*/
public class TestSynchronized {
    public static void main(String[] args) {
        ThreadSyn threadSyn = new ThreadSyn();
        ThreadSyn threadSyn2 = new ThreadSyn();
        Thread thread1 = new Thread(threadSyn, "ThreadSynOne");
        Thread thread2 = new Thread(threadSyn2, "ThreadSynTwo");
        thread1.start();
        thread2.start();
    }
}

1-3. 多个线程访问synchronized和非synchronized代码块

一个线程访问对象 的同步代码块，另一个线程可以访问该对象的非同步代码；两者不互斥。

/*
    根据线程名称来区分，进入synchronized同步代码块，或进入非synchronized代码块
*/
public class ThreadSyn implements Runnable {
    private volatile static Integer Count = 0;

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("ThreadSynOne")) {
            synchronized (this.Count) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " count :" + (Count++));
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } else if (threadName.equals("ThreadSynTwo")) {
            for (int j = 0; j < 5; j++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " j :" + j);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

小技巧：

如果只是想通过synchronized来同步代码块，而不是像synchronized(obj)之类的给obj对象加锁，则可以使用如下的方法来构建轻量的锁对象。

    零长度的byte数组对象创建起来将比任何对象都经济，查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

class Test implements Runnable {
    private final byte[] LOCK= new byte[0];  // 特殊的instance变量，堆上创建，对象的引用地址不可变

    public void method() {
        synchronized (this.LOCK) {
            // todo 同步代码块
        }
    }

    public void run() {

    }
}

2 synchronized修饰一个方法

synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。如将上面demo中的run()方法改成如下的方式，实现的效果一样。

注意点：

1. synchronized关键字不能继承。

    虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。

    如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。

    还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

/*
    场景一：子类显式得增加synchronized关键字
*/
class Parent {
    public synchronized void method() {
        //todo
    }
}

class Child extends Parent {
    @Override
    public synchronized void method() {
        //todo
    }
}

/*
    场景二：子类调用父类的同步方法
*/
class Parent {
    public synchronized void ParentMethod() {
        //todo
    }
}

class Child extends Parent {
    public void childMethod() {
        super.ParentMethod();
    }
}

2、 在定义接口方法时不能使用synchronized关键字。
       构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

3、Synchronized修饰方法的缺陷

同步方法，这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。

也就是说，当一个对象 P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加 了synchronized关键字的方法。

同步方法实质是将synchronized作用于object reference(对象的引用，即对象在堆上创建的地址)。

线程拿到了P1对象锁，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱。

若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized代码块（上面已经说了）

3 synchronized修饰静态方法

静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

/*
    threadSynOne和threadSynTwo是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。
    这是因为run中调用了静态方法method，而静态方法是属于类的，所以threadSynOne和threadSynTwo相当于用了同一把锁。
*/
public class ThreadSyn implements Runnable {
    private volatile static int count = 0;

    @Override
    public void run() {
        method();
    }

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

4.synchronized作用于一个类

synchronized作用于一个类时，是给这个类加锁，这个类的所有对象用的是同一把锁

/*
    给类加锁
*/
public class ThreadSyn implements Runnable {
    private volatile static int count = 0;

    @Override
    public void run() {
        method();
    }

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

---

举例：Synchronized同步方法和同步代码块

1、因为同步方法锁的是方法的this，也就是执行这个方法的对象。

因为是起了两个对象（classLocker1 和classLocker2）作为两个线程，所以不存在竞争行为。

public class TestSynchronized {

    public static void main(String[] args) {
        TestSynchronized classLocker1 = new TestSynchronized();
        TestSynchronized classLocker2 = new TestSynchronized();
        new Thread(() -> classLocker1.lock()).start();
        new Thread(() -> classLocker2.lock()).start();

    }

    //修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
    //对象classLocker1和classLocker2为不同对象，不产生冲突
    private synchronized void lock() {
        int i = 0;
        do {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this + " is locked " + i);
        } while (i++ < 10);
    }
}

2、修改：两个线程改为都是执行对象1的lock方法，此时的结果必然为线程对象classLocker1，依次打印0—10，再打印0—10

public class TestSynchronized {

    public static void main(String[] args) {
        TestSynchronized classLocker1 = new TestSynchronized();
        TestSynchronized classLocker2 = new TestSynchronized();
        new Thread(() -> classLocker1.lock()).start();
        new Thread(() -> classLocker1.lock()).start();

    }

    //修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
    //对象classLocker1和classLocker2为不同对象，不产生冲突
    private synchronized void lock() {
        int i = 0;
        do {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this + " is locked " + i);
        } while (i++ < 10);
    }
}

3、若为同步代码块，同步代码块是显式声明资源。

public class TestSynchronized {

    public static void main(String[] args) {
        TestSynchronized classLocker1 = new TestSynchronized();
        TestSynchronized classLocker2 = new TestSynchronized();
        new Thread(() -> classLocker1.lock()).start();
        new Thread(() -> classLocker2.lock()).start();

    }

    //修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
    //对象classLocker1和classLocker2为不同对象，不产生冲突
    private void lock() {
        //synchronized (this)
        synchronized (this.getClass()) {
            int i = 0;
            do {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this + " is locked " + i);
            } while (i++ < 10);
        }
    }
}

• 当括号里是this时，锁的是当前调用方法的对象（依次为classLocker1和classLocker2）————运行结果必然是：classLocker1线程对象和classLocker2线程对象并行地打印0—10，因为是两个不同的对象占用的锁，互不影响；（对象锁）
• 当括号里是一个Class对象时，锁的是这个类，也就是同一个类的实例，任意时刻只会有一个线程能获得资源。——运行结果必然是：classLocker1线程对象打印0—10，然后classLocker2线程对象打印0—10；（类锁）