Java 并发编程

核心理论

1. 共享性

数据共享性是线程安全的主要原因之一。如果所有的数据只是在线程内有效，那就不存在线程安全性问题，这也是我们在编程的时候经常不需要考虑线程安全的主要原因之一。但是，在多线程编程中，数据共享是不可避免的。最典型的场景是数据库中的数据，为了保证数据的一致性，我们通常需要共享同一个数据库中数据，即使是在主从的情况下，访问的也同一份数据，主从只是为了访问的效率和数据安全，而对同一份数据做的副本

这种数据的共享性会导致问题的发生、

public class ShareData {public static int count = 0;public static void main(String[] args) {final ShareData data = new ShareData();for (int i = 0; i < 10; i++) {new Thread(new Runnable() {@Overridepublic void run() {try {//进入的时候暂停1毫秒，增加并发问题出现的几率Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}for (int j = 0; j < 100; j++) {data.addCount();}System.out.print(count + " ");}}).start();}try {//主程序暂停3秒，以保证上面的程序执行完成Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("count=" + count);}public void addCount() {count++;}
}

上面使用10个线程来执行对count的1000次+1操作最后的输出并不一定是1000

2. 原子性

原子性就是指对数据的操作是一个独立的、不可分割的整体。换句话说，就是一次操作，是一个连续不可中断的过程，数据不会执行的一半的时候被其他线程所修改

通过加锁可以实现原子性

3. 可见性

每个线程都有一个自己的工作内存（相当于CPU高级缓冲区，这么做的目的还是在于进一步缩小存储系统与CPU之间速度的差异，提高性能），对于共享变量，线程每次读取的是工作内存中共享变量的副本，写入的时候也直接修改工作内存中副本的值，然后在某个时间点上再将工作内存与主内存中的值进行同步。这样导致的问题是，如果线程1对某个变量进行了修改，线程2却有可能看不到线程1对共享变量所做的修改

退不出的循环




解决办法
使用volatile关键字修饰变量，这样可以避免线程从自己的工作缓存查找变量值，必须到主存中获取

volatile就是可见性
保证了在多个线程之家，一个线程对volatile变量的修改对另外一个线程课件，不能保证原子性，仅仅是可以用在一个线程写多个线程读的情况

synchronized语句块是重量级的，既可以保证代码块内变量的可见性，也可以保证原子性，但是性能低

但是下列情况，我不用volatile但是在里面使用了打印语句，还是可以停下

因为Sytem.out里面使用了synchronized，保证了可见性

4. 有序性

为了提高性能，编译器和处理器可能会对指令做重排序


解决方法
使用volatile修饰变量就可以防止指令重排

synchronized的使用和实现原理

1. 修饰普通方法

相当于当前方法占据了对象

package com.paddx.test.concurrent;public class SynchronizedTest {public synchronized void method1(){System.out.println("Method 1 start");try {System.out.println("Method 1 execute");Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Method 1 end");}public synchronized void method2(){System.out.println("Method 2 start");try {System.out.println("Method 2 execute");Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Method 2 end");}public static void main(String[] args) {final SynchronizedTest test = new SynchronizedTest();new Thread(new Runnable() {@Overridepublic void run() {test.method1();}}).start();new Thread(new Runnable() {@Overridepublic void run() {test.method2();}}).start();}
}

2. 修饰静态方法

是对类的同步

package com.paddx.test.concurrent;public class SynchronizedTest {public static synchronized void method1(){System.out.println("Method 1 start");try {System.out.println("Method 1 execute");Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Method 1 end");}public static synchronized void method2(){System.out.println("Method 2 start");try {System.out.println("Method 2 execute");Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Method 2 end");}public static void main(String[] args) {final SynchronizedTest test = new SynchronizedTest();final SynchronizedTest test2 = new SynchronizedTest();new Thread(new Runnable() {@Overridepublic void run() {test.method1();}}).start();new Thread(new Runnable() {@Overridepublic void run() {test2.method2();}}).start();}}

3. 代码块同步

package com.paddx.test.concurrent;public class SynchronizedTest {public void method1(){System.out.println("Method 1 start");try {synchronized (this) {System.out.println("Method 1 execute");Thread.sleep(3000);}} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Method 1 end");}public void method2(){System.out.println("Method 2 start");try {synchronized (this) {System.out.println("Method 2 execute");Thread.sleep(1000);}} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Method 2 end");}public static void main(String[] args) {final SynchronizedTest test = new SynchronizedTest();new Thread(new Runnable() {@Overridepublic void run() {test.method1();}}).start();new Thread(new Runnable() {@Overridepublic void run() {test.method2();}}).start();}
}

4. 原理

4.1 对代码块加锁

package com.paddx.test.concurrent;public class SynchronizedDemo {public void method() {synchronized (this) {System.out.println("Method 1 start");}}
}

每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

① 如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

② 如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

③ 如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权

4.2 同步方法

package com.paddx.test.concurrent;public class SynchronizedMethod {public synchronized void method() {System.out.println("Hello World!");}
}

从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成（理论上其实也可以通过这两条指令来实现），不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。

4.3 同步静态方法

获得的是类对象的monitor

线程间的协作

1. wait

wait()方法的作用是将当前运行的线程挂起（即让其进入阻塞状态），直到notify或notifyAll方法来唤醒线程.

调用wait方法后，线程是会释放对monitor对象的所有权的

wait方法的使用必须在同步的范围内，否则就会抛出IllegalMonitorStateException异常，wait方法的作用就是阻塞当前线程等待notify/notifyAll方法的唤醒，或等待超时后自动唤醒。

package com.paddx.test.concurrent;public class WaitTest {public void testWait(){System.out.println("Start-----");try {wait(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("End-------");}public static void main(String[] args) {final WaitTest test = new WaitTest();new Thread(new Runnable() {@Overridepublic void run() {test.testWait();}}).start();}
}

等待结束会报错，因为并没有监视器

Start-----
Exception in thread "Thread-0" java.lang.IllegalMonitorStateExceptionat java.lang.Object.wait(Native Method)at com.paddx.test.concurrent.WaitTest.testWait(WaitTest.java:8)at com.paddx.test.concurrent.WaitTest$1.run(WaitTest.java:20)at java.lang.Thread.run(Thread.java:745)

正确的用法是在同步范围使用

package com.paddx.test.concurrent;public class WaitTest {public synchronized void testWait(){//增加Synchronized关键字System.out.println("Start-----");try {wait(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("End-------");}public static void main(String[] args) {final WaitTest test = new WaitTest();new Thread(new Runnable() {@Overridepublic void run() {test.testWait();}}).start();}
}

2. notify/notifyAll方法

通过对象的monitor对象来实现的，所以只要在同一对象上去调用notify/notifyAll方法，就可以唤醒对应对象monitor上等待的线程了。notify和notifyAll的区别在于前者只能唤醒monitor上的一个线程，对其他线程没有影响，而notifyAll则唤醒所有的线程

package com.paddx.test.concurrent;public class NotifyTest {public synchronized void testWait(){System.out.println(Thread.currentThread().getName() +" Start-----");try {wait(0);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() +" End-------");}public static void main(String[] args) throws InterruptedException {final NotifyTest test = new NotifyTest();for(int i=0;i<5;i++) {new Thread(new Runnable() {@Overridepublic void run() {test.testWait();}}).start();}synchronized (test) {test.notify();}Thread.sleep(3000);System.out.println("-----------分割线-------------");synchronized (test) {test.notifyAll();}}
}

3. sleep

sleep方法的作用是让当前线程暂停指定的时间（毫秒），sleep方法是最简单的方法，在上述的例子中也用到过，比较容易理解。唯一需要注意的是其与wait方法的区别。最简单的区别是，wait方法依赖于同步，而sleep方法可以直接调用。而更深层次的区别在于sleep方法只是暂时让出CPU的执行权，并不释放锁。而wait方法则需要释放锁

wait/notify/notifyAll方法的作用是实现线程间的协作，那为什么这三个方法不是位于Thread类中，而是位于Object类中？

位于Object中，也就相当于所有类都包含这三个方法（因为Java中所有的类都继承自Object类）。要回答这个问题，还是得回过来看wait方法的实现原理，大家需要明白的是，wait等待的到底是什么东西？如果对上面内容理解的比较好的话，我相信大家应该很容易知道wait等待其实是对象monitor，由于Java中的每一个对象都有一个内置的monitor对象，自然所有的类都理应有wait/notify方法。