多线程并发访问同步问题。
java中每个对象编译后的字节码中，有个头部。
头部存储着hashcode，对象垃圾回收的年龄，还有就是内部锁信息。
线程间互斥同步就是使用synchronized实现的，synchronized关键字，在编译后，会在同步块的前后，生成monitor enter和monitor exit字节码指令。关键字锁住的是对象的锁。
synchronized关键字加锁的过程是怎样？
- java代码碰到synchronized关键字，在编译后，会在同步块的前后，生成monitor enter和monitor exit字节码指令。
- 线程碰到monitor enter指令后，会先判断，这个对象的锁有没有被别的线程占用，如果没有，就占用锁，并在锁的计数器上+1（锁是可以被同一个线程重入的，所以不会存在自己死锁的情况）。
- 如果发现对象的锁已经被占用，线程就阻塞等待。
- 当拿到锁的线程执行到monitor exit时，锁的计数器-1，当对象的锁计数器为0时，表示对象的锁被释放了。别的线程可以去拿到锁，进入同步代码块了。
java的线程使用synchronized关键字同步相较于，其他的一些操作，是很重的耗性能的操作。因为在互斥等待唤醒的操作中，java线程底层是要跟操作系统内核线程去映射的。所以开发人员在使用的时候应该特别小心哈。
因为耗性能，所以也有了相应的优化的锁的概念。要根据场景去使用设置。
对象的锁有重度锁，轻量级锁，偏向锁（大概的实现思路，就跟数据库的乐观锁是一个概念）。
synchronized关键字可以作用在哪些地方，分别的作用范围是怎样？
代码块，方法，静态方法，类
-
作用在代码块时：
结论：synchronized代码块只会影响同一对象（因为锁的是对象）的所有synchronized代码块的同步访问，不影响不同对象的同步访问，不影响同一对象的非synchronized代码块的同步访问。 -
作用在方法
结论：跟作用在代码块是一样。
public class ThreadTest implements Runnable{
private static int count = 0;
private synchronized void increase() {
for (int i = 0; i < 3; i++) {
try {
System.out.println(Thread.currentThread().getName() + " ：" + count++);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void run() {
increase();
}
public static void main(String[] args) {
//同一个对象
ThreadTest threadTest = new ThreadTest();
Thread t1 = new Thread(threadTest, "t1");
Thread t2 = new Thread(threadTest, "t2");
t1.start();
t2.start();
}
}
运行结果
能看出来是互斥同步的，线程2在线程1执行结束，才开始执行。
如果不同的线程作用在不同的对象上：
public static void main(String[] args) {
//不同线程作用在不同的对象上
Thread t1 = new Thread(new ThreadTest(), "t1");
Thread t2 = new Thread(new ThreadTest(), "t2");
t1.start();
t2.start();
}
运行结果：
能看出来，线程间是没有约束的。
然而，synchronized可以修饰方法，但它不属于方法的一部分，因此，synchronized关键字不能被继承。如果父类方法使用synchronized关键字，而子类中覆盖了该方法，则子类这个方法默认是不同步的，必须显式地加上synchronized关键字才会同步。但是，若在子类中调用父类相应的同步方法，则子类的方法也就相当于同步了。
- 作用在静态方法上
public class ThreadTest implements Runnable{
private static int count = 0;
private synchronized static void increase() {
for (int i = 0; i < 3; i++) {
try {
System.out.println(Thread.currentThread().getName() + " ：" + count++);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void run() {
increase();
}
public static void main(String[] args) {
Thread t1 = new Thread(new ThreadTest(), "t1");
Thread t2 = new Thread(new ThreadTest(), "t2");
t1.start();
t2.start();
}
}
两个线程作用在不同的对象上，运行结果也是互斥同步的。
结论：跟作用在方法上不同，synchronized修饰静态方法时，作用范围是整个静态方法，作用的对象是这个类的所有对象。这是因为静态方法是属于类的而不属于对象，synchronized的内部锁锁定这个类所有对象。
- 作用在类上
public class ThreadTest implements Runnable{
private static int count = 0;
private void increase() {
synchronized (ThreadTest.class) {
for (int i = 0; i < 3; i++) {
try {
System.out.println(Thread.currentThread().getName() + " ：" + count++);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
@Override
public void run() {
increase();
}
public static void main(String[] args) {
Thread t1 = new Thread(new ThreadTest(), "t1");
Thread t2 = new Thread(new ThreadTest(), "t2");
t1.start();
t2.start();
}
}
结论：作用范围是synchronized后面{}内的部分，作用的对象也是这个类的所有对象（跟作用在静态方法上一样）。
tips：
只要明白synchronized关键字是通过对象的内部锁来实现同步的，再针对具体情况具体分析（静态方法、方法、类、代码块），很快便能搞明白synchronized关键字的含义和用法。
《深入理解java虚拟机》 周志明
参考文章：https://juejin.im/entry/58070aabd20309006863772c
