Java多线程同步的五种方法
一、目的
有赞突击面试，毫无防备，这个问题好像被别的公司也问过，没答上来，所以总结一下。
二、为什么要线程同步
- 因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。
- 比如一个银行账户，一个取100元，一个存100元。假设原来只有0元，看看会出现什么结果。
三、不同情况下的结果
- 不使用同步方法：
package com.thread.test;
public class Bank {
private int count = 0; //银行账户
//存钱
public void addMoney( int money) {
count += money;
System.out.println(System.currentTimeMillis()+"存进：" +money);
}
//取钱
public void subMoney(int money) {
if(count-money<0){
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis()+"取出+"+money);
}
//查询
public void lookMoney() {
System.out.println("账户余额：" +count);
}
}
package com.thread.test;
public class SyncThreadTest {
public static void main(String[] args) {
final Bank bank = new Bank();
Thread tadd = new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
bank.addMoney(100);
bank.lookMoney();
System.out.println("\n");
}
}
});
Thread tsub = new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try{
Thread.sleep(1000);
}catch (Exception e) {
e.printStackTrace();
}
bank.subMoney(100);
bank.lookMoney();
System.out.println("\n");
}
}
});
tsub.start();
tadd.start();
}
}两个进程：（1）存钱，（2）取钱。
1528689141841存进：100
账户余额：100
1528689141942存进：100
账户余额：200
1528689142042存进：100
账户余额：300
1528689142142存进：100
账户余额：400- （1）synchronized关键字同步方法：
- 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
package com.thread.test;
public class SynchronizedBank {
private int count = 0; //银行账户
//存钱
public synchronized void addMoney( int money) {
count += money;
System.out.println(System.currentTimeMillis()+"存进：" +money);
}
//取钱
public synchronized void subMoney(int money) {
if(count-money<0){
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis()+"取出+"+money);
}
//查询
public void lookMoney() {
System.out.println("账户余额：" +count);
}
}结果：
1528697968158存进：100
账户余额：100
1528697968162取出+100
账户余额：0
1528697969159存进：100
账户余额：100
1528697969163取出+100
账户余额：0
- （2）synchronized关键字同步代码块
- 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
package com.thread.test;
public class SynchronizedBank_block {
private int count = 0; //银行账户
//存钱
public void addMoney( int money) {
synchronized (this) {
count += money;
}
System.out.println(System.currentTimeMillis()+"存进：" +money);
}
//取钱
public synchronized void subMoney(int money) {
synchronized(this){
if(count-money<0){
System.out.println("余额不足");
return;
}
count -= money;
}
System.out.println(+System.currentTimeMillis()+"取出+"+money);
}
//查询
public void lookMoney() {
System.out.println("账户余额：" +count);
}
}
运行结果：
1528699402342取出+100
账户余额：0
1528699403346存进：100
账户余额：100
1528699403347取出+100
账户余额：0
1528699404347存进：100
账户余额：100
注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
- （3）使用特殊域变量(volatile)实现线程同步
- volatile关键字为域变量的访问提供了一种免锁机制
- 使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
- 因此每次使用该域就要重新计算，而不是使用寄存器中的值
- volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
package com.thread.test;
public class VolatileBank {
private volatile int count = 0; //银行账户
//存钱
public void addMoney( int money) {
count += money;
System.out.println(System.currentTimeMillis()+"存进：" +money);
}
//取钱
public void subMoney(int money) {
if(count-money<0){
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis()+"取出+"+money);
}
//查询
public void lookMoney() {
System.out.println("账户余额：" +count);
}
}
余额不足
账户余额：0
1528700014203存进：100
账户余额：100
1528700015198取出+100
账户余额：0
1528700015203存进：100
账户余额：100
1528700016198取出+100
账户余额：0
1528700016203存进：100
账户余额：100- 因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。
- 此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。
- 它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。
- （4）使用ReentrantLock的重入锁实现线程同步
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
1528700957237存进：100
账户余额：100
1528700958238取出+100
账户余额：0
1528700958238存进：100
账户余额：100
1528700959238存进：100
1528700959238取出+100
账户余额：100
账户余额：100
1528700960239存进：100
账户余额：200
1528700960240取出+100
账户余额：100- 如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。
- 如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 。
- （5）使用局部变量ThreadLocal实现线程同步
package com.thread.test;
public class ThreadLocalBank {
private static ThreadLocal count = new ThreadLocal(){
@Override
protected Integer initialValue() {
return 10000;
}
};
//存钱
public void addMoney( int money) {
count.set(count.get()+money);
System.out.println(System.currentTimeMillis()+"存进：" +money);
}
//取钱
public void subMoney(int money) {
if(count.get()-money<0){
System.out.println("余额不足");
return;
}
count.set(count.get()-money);;
System.out.println(+System.currentTimeMillis()+"取出: "+money);
}
//查询
public void lookMoney() {
System.out.println("账户余额：" +count.get());
}
} 结果：
1528703214170取出: 100
账户余额：9900
1528703214170存进：100
账户余额：10100
1528703215171取出: 100
账户余额：9800
1528703215172存进：100
账户余额：10200
1528703216171取出: 100
账户余额：9700
1528703216172存进：100
账户余额：10300
1528703217171取出: 100
账户余额：9600
1528703217172存进：100
账户余额：10400
1528703218171取出: 100
账户余额：9500
1528703218172存进：100
账户余额：10500
1528703219171取出: 100
账户余额：9400
1528703219173存进：100
账户余额：10600
1528703220171取出: 100
账户余额：9300
1528703220173存进：100
账户余额：10700- 如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
- 现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。
参考：https://blog.csdn.net/wenwen091100304/article/details/48318699