java并发基础

九月 07, 2018 本文总阅读量次

本系列文章主要讲解Java并发相关的内容，包括同步、锁、信号量、阻塞队列、线程池等，整体思维导图如下：
此处输入图片的描述

本文主要讲解Java内存模型、同步块、重入锁ReentrantLock和读写锁ReentrantReadWriteLock的应用及源码实现。
同步和锁
我们之所以要用多线程并发，是为了更好地利用服务器资源，使程序的响应速度更好。然而，如果多个线程访问了相同的资源，如同一内存区的变量、数组和对象，以及外部数据库或者文件等，可能导致程序的运行结果和我们预期的不一致。
假设你家庭成员都用同一个银行账户，每天都有收入或者支出，我们来看如下的代码：
package com.molyeo.java.concurrent;

/**

Created by zhangkh on 2018/8/24.
*/
public class SynchronizedDemo {
public static void main(String[] args){

Account account=new Account();
account.setBalance(100000);
System.out.printf("Account : Initial Balance: %f",account.getBalance());
Spender spender=new Spender(account);
Thread spenderThread=new Thread(spender);
spenderThread.start();
Earner earner=new Earner(account);
Thread earnerThread=new Thread(earner);
earnerThread.start();
try {
    spenderThread.join();
    earnerThread.join();
    System.out.printf("Account : Final Balance: %f",account.getBalance());
} catch (InterruptedException e) {
    e.printStackTrace();
}

}
}
SynchronizedDemo类先创建一个账户，然后将账户实例传递给Spender线程(每个月花钱的败家子)和Earner线程(挣钱养家的家庭成员)，然后启动这两个线程。
其中Account的代码如下：
public class Account{
private double balance;

public double getBalance() {

return balance;

}

public void setBalance(double balance) {

this.balance = balance;

}

public void addAmount(double amount) {

try{
    Thread.sleep(10);
}catch (Exception e){
    e.printStackTrace();
}
balance=balance+amount;

}
public void subtractAmount(double amount){

try{
    Thread.sleep(10);
}catch (Exception e){
    e.printStackTrace();
}
balance=balance-amount;

}
}
Account拥有一个成员变量balance,用于记录账户余额，对外提供一个增加余额addAmount()和减少余额subtractAmount()的方法。
Spender和Earner代码如下：
class Spender implements Runnable {
private Account account;
public Spender(Account account) {

this.account=account;

}
@Override
public void run() {

for (int i=0; i<30; i++){
    account.subtractAmount(1000);
}

}
}

class Earner implements Runnable{
private Account account;
public Earner(Account account) {
this.account=account;
}
@Override
public void run() {
for (int i=0; i<30; i++){
account.addAmount(1000);
}
}
}
Spender线程每个月花钱30次，每次花1000人民币；Earner线程挣钱30次，每次挣1000人民币。
SynchronizedDemo程序中先设置账户余额为10万元，可以认为是家庭存款，按照预期的结果，这个月败家子花了3万，养家的爸妈一起挣了3万，这个月后结算，家里存款还是10万。虽然爸妈这个月白忙了，但是败家子还是先别内疚了，先看看程序的输出。
第一次运行输出结果如下(由于有一定的随机性，结果不一定完全相同)：
Account : Initial Balance: 100000.000000
Account : Final Balance: 99000.000000
第二次运行输出结果如下(由于有一定的随机性，结果不一定完全相同)：
Account : Initial Balance: 100000.000000
Account : Final Balance: 112000.000000
程序到底怎么了呢，好好地每次运行结果还不一致了？要深入分析这个问题，我们要先了解下Java的内存模型。
Java内存模型
Java内存模型规范了Java虚拟机和计算机内存的协同工作机制，简单的说就是说明了如何和何时可以看到由其他线程修改后的共享变量的值，以及在必须时如何同步地访问共享变量。
Java内存模型逻辑视图
Java内存模型把Java虚拟机划分为线程栈和堆。
此处输入图片的描述

每个运行在Java虚拟机中的线程拥有自己的线程栈，包含线程调用的方法当前执行点相关的信息。同时一个线程也仅仅能访问自己的线程栈，线程创建的本地变量仅自己可见，其他线程不可见。
原始类型(boolean, byte, short, char, int, long, float, double)的本地变量都存放在线程栈上,而Java程序中创建的对象都存在在堆上，不管是自定义的自定义对象，还是原始类型的包装对象(如Byte, Integer, Long等)。下面这张图演示了调用栈和本地变量存放在线程栈上，对象存放在堆上。
此处输入图片的描述
变量到底是存放在线程栈上还是堆上，有如下几点说明：
本地变量如果是原始类型，则始终存在线程栈上
本地变量如果是对象的引用，则这个引用存在现在线程栈上，而对象存在堆上
一个对象的方法中的本地变量存在线程栈上，即使这个对象存放在堆上
对象的成员变量和对象本身一起存放在堆上，不管成员变量是原始类型还是引用类型
静态成员变量也是存放在堆上
存放在堆上的对象可以被所有持有对这个对象引用的线程访问。当一个线程可以访问一个对象时，它也可以访问这个对象的成员变量。如果两个线程同时调用同一个对象上的同一个方法，它们将会都访问这个对象的成员变量，但是每一个线程都拥有这个本地变量的私有拷贝。
硬件内存架构
现代硬件内存模型与Java内存模型有一些不同。理解内存模型架构以及Java内存模型如何与它协同工作也是非常重要的。
现代计算机硬件架构简单图示如下：
此处输入图片的描述
现代计算机通常由两个或者多个CPU组成,拥有寄存器，缓存，和主存，其中访问速度寄存器最高，缓存次之，再者就是主存。
通常情况下，当一个CPU需要读取主存时，它会将主存的部分读到CPU缓存中。它甚至可能将缓存中的部分内容读到它的内部寄存器中，然后在寄存器中执行操作。当CPU需要将结果写回到主存中去时，它会将内部寄存器的值刷新到缓存中，然后在某个时间点将值刷新回主存。
需要注意的是，当CPU需要在缓存层存放一些东西的时候，存放在缓存中的内容通常会被刷新回主存。CPU缓存可以在某一时刻将数据局部写到它的内存中，和在某一时刻局部刷新它的内存。它不会再某一时刻读/写整个缓存，通常是一个或者多个缓存行被读取或者写入。
硬件内存架构没有区分线程栈和堆。对于硬件，所有的线程栈和堆都分布在主内中。部分线程栈和堆可能有时候会出现在CPU缓存中和CPU内部的寄存器中。如下图所示：
此处输入图片的描述
当对象和变量被存放在计算机中各种不同的内存区域中时，就有可能会出现一些问题，主要包括两个方面：
共享变量修改的可见性
多线程读写共享变量时出现竞态条件
我们以上面的SynchronizedDemo例子，从硬件内存架构来分析这两个问题。
可见性
Account的成员变量balance被初始化为100000后，保存在主存中。Spender线程首次将这个共享对象读取到缓存后，调用subtractAmount()方法减少了balance的值。如果此时缓存数据没有被刷新到主存，则更改后的值对其他线程是不可见的。
而此时Earner线程也将共享对象拷贝到缓存中，注意此时的共享对象的值还是100000，然后调用addAmount()方法增加balance的值。这样两个线程多次更改后，导致最后balance的结果是不确定的，进而出现每次运行的结果可能不太一致。
为了解决共享变量的可见性问题，可以使用Java中的volatile关键字，其可以保证直接从主存中读取一个变量，如果这个变量被修改后，总是会被写到主存中去。
看到这里后，我们可以尝试对Account的成员变量balance使用volatile修饰，然后多次运行上述程序，看结果是否保持一致。
Account修改内容如下：
private volatile double balance;
为了避免多次运行，我们在SynchronizedDemo的主程序中，直接循环10次：
public class SynchronizedDemo {
public static void main(String[] args){
for(int i=0;i<10;i++){
Account account = new Account();
account.setBalance(100000);
System.out.printf(“Account : Initial Balance: %s”,account.getBalance());
Spender spender=new Spender(account);
Thread spenderThread=new Thread(spender);
spenderThread.start();
Earner earner=new Earner(account);
Thread earnerThread=new Thread(earner);
earnerThread.start();
try {
spenderThread.join();
earnerThread.join();
System.out.printf(“Account : Final Balance: %s”,account.getBalance());
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“——————————————————“);
}
}
}
让我们来见证奇迹的发生，看看程序的输出结果：
Account : Initial Balance: 100000.0