java高并发编程之线程安全与数据同步

什么是共享资源？共享资源指的是多个线程同时对同一份资源进行访问，被多个线程访问的资源就称为共享资源，如何保证多个线程访问到的数据时一致的，则被称为数据同步或者资源同步。

4.1 数据同步

4.1.1 数据不一致引入的问题

public class MyThread extends Thread{
	int count = 5;
	public void run() {
		while(count>0) {
			System.out.println(Thread.currentThread().getName()+":"+count--);
		}
	}

}
...................
public class Test {
	
 public static void main(String[] args) throws InterruptedException {
	
	 MyThread thread = new MyThread();
	 Thread t = new Thread(thread);
	 Thread t2 = new Thread(thread);
	 Thread t3 = new Thread(thread);
	 Thread t4 = new Thread(thread);
	 
	 t.start();
	 t2.start();
	 t3.start();
	 t4.start();
 	}
}
......................
运行结果：
Thread-2:5
Thread-2:4
Thread-2:3
Thread-2:2
Thread-2:1
Thread-1:0
------------
Thread-1:10
Thread-1:9
Thread-1:8
Thread-1:6
Thread-4:7
Thread-2:10
Thread-2:2
Thread-1:4
Thread-3:5
Thread-2:1
Thread-4:3

出现上述为题的原因是，可能几个线程都执行到了这一句，

System.out.println(Thread.currentThread().getName()+":"+count--);

线程2让出了CPU执行权，线程1获取了CPU执行权，继续执行，导致count为0.
如果在这句代码之前有什么东西控制一下就好了，让每个线程进入这样的临界代码之前都检查一下，并且只能一个个进。
解决上述问题，需要用到synchronized关键字

4.2 初识synchronized关键字

4.2.1 什么是synchronized关键字

synchronized关键字可以实现一个简单的策略来防止线程干扰和内存一致性错误，如果一个对象对多个线程是可见的，那么该对象的所有读或者写都将通过同步的方式来进行，具体表现如下：
1.synchronized关键字提供了一种锁的机制，能够确保共享变量的互斥访问，从而防止数据不一致问题的出现
2.synchronized关键字包括monitor enter和monitor exit两个JVM指令，他能够保证在任何时候任何线程执行到monitor enter成功之前都必须从主存中获取数据，而不是缓存中，在monitor exit运行成功之后，共享变量被更新后的值必须刷人主内存。
3.synchronized的指令严格遵守java happens-before规则，一个monitor exit指令之前必定要有一个monitor enter
4.2.2 synchronized关键字的用法

synchronized可以用于对代码块或方法进行修饰，而不能够用于对class以及变量进行修饰。
1.同步方法
public synchronized …(){

}
2.同步代码块
public …(){
synchronized(对象){

}

}
4.3 深入synchronized关键字

4.3.1 线程堆栈分析

synchronized关键字提供了一种互斥机制，也就是说在同一时刻，只能有一个线程访问同步资源，很多资料、书籍将synchronized（mutex）称为锁，其实这个说法不严谨，准确的讲应该是某线程获取了与mutex关联的monitor锁。

4.3.2 JVM指令分析

public class MyThread extends Thread{
	private final Object obj = new Object();
	int count = 10;
	public   void run() {
		synchronized(obj) {
			while(count>0) {
				System.out.println(Thread.currentThread().getName()+":"+count--);
			}
		}	
		}
}

反汇编：
public void run();
    Code:
       0: aload_0
       1: getfield      #17                 // Field obj:Ljava/lang/Object;
       4: dup
       5: astore_1
       6: monitorenter
       7: goto          54
      10: getstatic     #26                 // Field java/lang/System.out:Ljava/io/PrintStream;
      13: new           #32                 // class java/lang/StringBuilder
      16: dup
      17: invokestatic  #34                 // Method java/lang/Thread.currentThread:()Ljava/lang/Thread;
      20: invokevirtual #38                 // Method java/lang/Thread.getName:()Ljava/lang/String;
      23: invokestatic  #42                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
      26: invokespecial #48                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
      29: ldc           #51                 // String :
      31: invokevirtual #53                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      34: aload_0
      35: dup
      36: getfield      #19                 // Field count:I
      39: dup_x1
      40: iconst_1
      41: isub
      42: putfield      #19                 // Field count:I
      45: invokevirtual #57                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      48: invokevirtual #60                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      51: invokevirtual #63                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      54: aload_0
      55: getfield      #19                 // Field count:I
      58: ifgt          10
      61: aload_1
      62: monitorexit
      63: goto          69
      66: aload_1
      67: monitorexit
      68: athrow
      69: return
...........................

(1)Monitorenter
每个对象都与一个monitor相关联，一个monitor的lock的锁只能被一个线程在同一时间获得，在一个线程尝试获得与对象关联monitor的所有权时会发生如下的几件事情。
1.如果monitor的计数器为0则意味着该monitor的lock还没有被获得，某个线程获得之后将立即对该计数器加一，从此该线程就是这个monitor的所有者了。
2.如果已经拥有该monitor所有权的线程重入，则会导致monitor计数器再次累加
3.如果monitor已经被其他线程拥有，则其他线程尝试获取该monitor的所有权时，会被陷入阻塞状态直到monitor计数器变为0，才能再次尝试获取对monitor的所有权。

（2）Monitorexit
释放对monitor的所有权，想要释放某个对象关联的monitor的所有权的前提是，你曾经获得了所有权。释放monitor所有权的过程比较简单，就是将monitor的计数器减1，如果计数器的值为0，意味着，该线程不再拥有对象monitor的所有权，通俗的讲就是解锁。与此同时被该monitor block的线程将再次尝试获得对该monitor的所有权。

4.3.3 使用synchronized需要注意的问题

1.与monitor关联的对象不能为空
2.synchronized作用域太大
由于synchronized关键字存在排他性，也就是说所有的线程必须串行地经过synchronized保护的共享区域，如果synchronized作用域越大，则代表着其效率越低，甚至会丧失并发的优势。
3.不同的monitor企图锁相同的方法

public class Test implements Runnable{
	private final Object mutex = new Object();
	public void run() {
		synchronized(mutex) {
			
		}
	}
	
 public static void main(String[] args) throws InterruptedException {
	 for(int i = 0;i<5;i++) {
		 new Thread(Test::new).start();
	 }
 }
}

上面的代码构造了五个线程，同时也构造了五个Runnable实例，Runnable作为线程逻辑执行单元传递给Thread,然后你将发现，synchronized根本互斥不了与之对应的作用域，线程之间进行monitor lock的争抢只能发生在于monitor关联的同一个引用上，上面的代码每一个线程争抢的monitor关联引用都是彼此独立的，因此不可能起到互斥的作用。
4.多个锁的交叉导致死锁

4.5 程序死锁

1.交叉锁可导致程序出现死锁
2.内存不足
3.一问一答式的数据交换
4.数据库锁
5.文件锁
6.死循环引起的死锁