java多线程同步编程

学习java有一段时间了，一直对java的多线程同步理解的不够深刻，今天将我学习的过程记录下来帮助大家一起来学习深刻理解java的多线程同步策略

现实生活中多线程同步场景很多，比如说我的银行卡里面的money数是100，我自己正在银行存10元，而这时候我老婆正在超市用支付宝消费10，那么我的余额应该是不变对吧，但是如果没有做线程同步那么数字会发生变化，这是很危险的。

我们先来见识一下多线程运行不同步的一个例子

下面是我的银行类：

import java.text.SimpleDateFormat;import java.util.Date;public class Bank {    private int count =0;//账户余额    //存钱    public  void addMoney(int money){        count +=money;        System.out.println(getCurrentTime()+"存进："+money);    }    //取钱    public  void subMoney(int money){        if(count-money < 0){            System.out.println("余额不足");            return;        }        count -=money;        System.out.println(getCurrentTime()+"取出："+money);    }    //查询    public void lookMoney(){        System.out.println(getCurrentTime()+"账户余额："+count);    }    public static String getCurrentTime() {        String returnStr = null;        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        Date date = new Date();        returnStr = f.format(date);        return returnStr;    }}

这边是取款存款操作两个线程：

/** * Created by mac on 16/9/8. */public class MutiThreadSyn {    public static void main(String args[]){        final Bank bank=new Bank();        Thread tadd=new Thread(new Runnable() {            @Override            public void run() {                for(int i=0;i<=3;i++) {                    bank.addMoney(i*10);                    System.out.println("\n");                }                bank.lookMoney();                }        });        Thread tsub = new Thread(new Runnable() {            @Override            public void run() {                for(int i=0;i<=3;i++) {                    bank.subMoney(i*10);                    System.out.println("\n");                }                bank.lookMoney();            }        });        tsub.start();        tadd.start();    }}

运行结果如下：

2016-09-08 18:21:37存进：02016-09-08 18:21:37取出：02016-09-08 18:21:37取出：10余额不足余额不足2016-09-08 18:21:37存进：102016-09-08 18:21:37账户余额：202016-09-08 18:21:37存进：202016-09-08 18:21:37存进：302016-09-08 18:21:37账户余额：50Process finished with exit code 0

可以看出我们的结果不是正确，多运行几次你会发现结果是随机的不是确定的，这是很危险的，所以我们要做线程同步。

线程同步的网上说的方法有很多我们一个一个来试验一下

1、synchronized关键字来实现

 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。这样无论有多少个线程同时在运行，最终都会按顺序一个一个的运行这个方法。这样结果就不会发生错误了。

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

import java.text.SimpleDateFormat;import java.util.Date;public class Bank {    private int count =0;//账户余额    //存钱    public  void addMoney(int money){        synchronized(this) {count +=money;}        System.out.println(getCurrentTime()+"存进："+money);    }    //取钱    public  void subMoney(int money){        synchronized(this) {            if(count-money < 0){            System.out.println("余额不足");            return;             }            count -=money;}        System.out.println(getCurrentTime()+"取出："+money);    }    //查询    public void lookMoney(){        System.out.println(getCurrentTime()+"账户余额："+count);    }    public static String getCurrentTime() {        String returnStr = null;        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        Date date = new Date();        returnStr = f.format(date);        return returnStr;    }}

这样结果就正确了（可以实现线程同步）

2016-09-08 18:46:48存进：02016-09-08 18:46:48取出：02016-09-08 18:46:48存进：102016-09-08 18:46:48取出：102016-09-08 18:46:48存进：202016-09-08 18:46:48取出：202016-09-08 18:46:48存进：302016-09-08 18:46:48取出：302016-09-08 18:46:48账户余额：02016-09-08 18:46:48账户余额：0Process finished with exit code 0

2、使用特殊域变量(Volatile)实现线程同步

如果一个变量加了volatile关键字，就会告诉编译器和JVM的内存模型：这个变量是对所有线程共享的、可见的，每次jvm都会读取最新写入的值并使其最新值在所有CPU可见。volatile似乎是有时候可以代替简单的锁，似乎加了volatile关键字就省掉了锁。但又说volatile不能保证原子性（java程序员很熟悉这句话：volatile仅仅用来保证该变量对所有线程的可见性，但不保证原子性）

至于其不能保证原子性见：http://www.cnblogs.com/Mainz/p/3556430.html#

主要原因是内存屏障导致的（Memory Barrier）

内存屏障（memory barrier）是一个CPU指令。基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。

内存屏障（memory barrier）和volatile什么关系？如果你的字段是volatile，Java内存模型将在写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作，你必须知道：1、一旦你完成写入，任何访问这个字段的线程将会得到最新的值。2、在你写入前，会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，因为内存屏障会把之前的写入值都刷新到缓存。

volatile为什么没有原子性?

明白了内存屏障（memory barrier）这个CPU指令，回到前面的JVM指令：从Load到store到内存屏障，一共4步，其中最后一步jvm让这个最新的变量的值在所有线程可见，也就是最后一步让所有的CPU内核都获得了最新的值，但中间的几步（从Load到Store）是不安全的，中间如果其他的CPU修改了值将会丢失

所以volatile只能说能实现比较弱的同步，因此volatile不能代替 synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。它的原理是每次要线程要访问volatile修饰 的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。

实现代码就是在Bank类 成员count前面加volatile修饰词：

private volatile int count =0;

不要将volatile用在getAndOperate场合（这种场合不原子，需要再加锁），仅仅set或者get的场景是适合volatile的

这样结果就正确了（可以实现线程同步）

2016-09-09 09:59:10取出：02016-09-09 09:59:10账户余额：10002016-09-09 09:59:10存进：02016-09-09 09:59:10取出：102016-09-09 09:59:10存进：102016-09-09 09:59:10取出：202016-09-09 09:59:10存进：202016-09-09 09:59:10取出：302016-09-09 09:59:10存进：302016-09-09 09:59:10账户余额：10002016-09-09 09:59:10账户余额：1000

3、使用重入锁实现线程同步

方法和synchronized修饰符类似就是在改变同步变量的代码段上加上锁代码如下：

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;import java.text.SimpleDateFormat;import java.util.Date;public class Bank {    private volatile int count =0;//账户余额    private Lock lock = new ReentrantLock();//定义一个同步锁    //存钱    public  void addMoney(int money){        lock.lock();        try{ count +=money;}        finally{        lock.unlock();//解锁         }        System.out.println(getCurrentTime()+"存进："+money);    }    //取钱    public  void subMoney(int money){        lock.lock();        try {            if (count - money < 0) {                System.out.println("余额不足");                return;            }            count -= money;        }        finally{            lock.unlock();//解锁        }        System.out.println(getCurrentTime()+"取出："+money);    }    //查询    public void lookMoney(){        System.out.println(getCurrentTime()+"账户余额："+count);    }    public static String getCurrentTime() {        String returnStr = null;        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        Date date = new Date();        returnStr = f.format(date);        return returnStr;    }}

结果正确了。（可以用作线程同步）

4、使用局部变量实现线程同步

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变 量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面 的效果。

ThreadLocal与同步机制

a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题

b.前者采用以”空间换时间”的方法，后者采用以”时间换空间”的方式

import java.text.SimpleDateFormat;import java.util.Date;public class Bank {    private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){        @Override        protected Integer initialValue() {            return 0;        }};    //存钱    public  void addMoney(int money){        count.set(count.get()+money);        System.out.println(getCurrentTime()+"存进："+money);    }    //取钱    public  void subMoney(int money){        if(count.get()-money < 0){            System.out.println("余额不足");            return;        }        count.set(count.get()-money);        System.out.println(getCurrentTime()+"取出："+money);    }    //查询    public void lookMoney(){        System.out.println(getCurrentTime()+"账户余额："+count.get());    }    public static String getCurrentTime() {        String returnStr = null;        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        Date date = new Date();        returnStr = f.format(date);        return returnStr;    }}

结果也是错误的。（不可以用作线程同步）

2016-09-09 09:50:41 存进：02016-09-09 09:50:41 取出：02016-09-09 09:50:41 账户余额：0余额不足余额不足余额不足2016-09-09 09:50:41 存进：102016-09-09 09:50:41 账户余额：02016-09-09 09:50:41 存进：202016-09-09 09:50:41 存进：302016-09-09 09:50:41 账户余额：60

总结：synchronized，重入锁可以实现线程同步而且是线程安全的，volatile虽然可以实现线程同步，但是其操作不具有原子性，所以只能单一get或者单一operation场景中使用，不然就会发生错误。最后threadlocal只能用来将一个变量提供多个本地副本供各线程访问，但是他不能保证这个变量的操作都同步。