JAVA并发编程 如何解决原子性问题
原文来自：https://www.cnblogs.com/liuyanling/p/12872798.html
java中的锁模型
锁是一种通用的技术方案，java 语言提供的 synchronized 关键字，就是锁的一种实现。
- synchronized 是独占锁/排他锁（就是有你没我的意思），但是注意！synchronized并不能改变cpu时间片切换的特点，只是当其他线程要访问这个资源时，发现锁还未释放，所以只能在外面等待。
- synchronized一定能保证原子性，因为被 synchronized 修饰某段代码后，无论是单核 cpu 还是多核 cpu，只有一个线程能够执行该代码，所以一定能保证原子操作
- synchronized也能够保证可见性和有序性。根据前第二篇文章：happens-before 规则之管程中锁的规则：对一个锁的解锁 happens-before 于后续对这个锁的加锁。即前一个线程的解锁操作对后一个线程的加锁操作可见。综合 happens-before 的传递性原则，我们就能得出前一个线程在临界区修改的共享变量（该操作在解锁之前），对后续进入临界区（该操作在加锁之后）的线程是可见的。- synchronized 关键字可以用来修饰静态方法，非静态方法，也可以用来修饰代码块
理论说完了，来点实际的吧！首先我们用synchronized 修饰非静态方法来改写第一章中原子性问题的那段代码：
private long count = 0;
// 修饰非静态方法 当修饰非静态方法的时候，锁定的是当前实例对象 this。
// 当该类中有多个普通方法被synchronized修饰（同步），那么这些方法的锁都是这个类的一个对象this。多个线程访问这些方法时，如果这些线程调用方法时使用的是同一个该类的对象，虽然他们访问不同方法，但是他们使用同一个对象来调用，那么这些方法的锁就是一样的，就是这个对象，那么会造成阻塞。如果多个线程通过不同的对象来调用方法，那么他们的锁就是不一样的，不会造成阻塞。
private synchronized void add10k(){
int start = 0;
while (start ++ < 10000){
this.count ++;
}
}
public static void main(string[] args) throws interruptedexception {
testsynchronized2 test = new testsynchronized2();
// 创建两个线程，执行 add() 操作
thread th1 = new thread(()->{
test.add10k();
});
thread th2 = new thread(()->{
test.add10k();
});
// 启动两个线程
th1.start();th2.start();
// 等待两个线程执行结束
th1.join();th2.join();
system.out.println(test.count);
}
运行一下吧！你会发现永远都可以达到我们想要的效果了~
除了上面代码中修饰非静态方法，还可以修饰静态方法和代码块
// 修饰静态方法 当修饰静态方法的时候，锁定的是当前类的 class 对象，即testsynchronized2.class 。这个范围就比对象锁大。这里就算是不同对象，但是只要是该类的对象，就使用的是同一把锁。
synchronized static void bar() {
// 临界区
}
// 修饰代码块 java中经典的双重锁检查机制
private volatile static testsynchronized2 instance;
public static testsynchronized2 getinstance() {
if (instance == null) {
synchronized (testsynchronized2.class) {
if (instance == null) {
instance = new testsynchronized2();
}
}
}
return instance;
}
明确锁和资源的关系
深入分析锁定的对象和受保护资源的关系，综合考虑受保护资源的访问路径，多方面考量才能用好互斥锁。受保护资源和锁之间的关联关系是 n:1 的关系。如果一个资源用n个锁，那肯定出问题的，就好像一个厕所坑位，你有10把钥匙，那不是可以10个人同时进了？
现在给出两段错误代码，想一想到底为啥错了吧？
static long value1 = 0l;
synchronized long get1() {
return value1;
}
synchronized static void addone1() {
value1 += 1;
}
long value = 0l;
long get() {
synchronized (new object()) {
return value;
}
}
第一段错误原因：
因为我们说过synchronized修饰普通方法 锁定的是当前实例对象 this 而修饰静态方法 锁定的是当前类的 class 对象
所以这里有两把锁 分别是 this 和 testsynchronized3.class
由于临界区 get() 和 addone() 是用两个锁保护的，因此这两个临界区没有互斥关系，临界区 addone() 对 value 的修改对临界区 get() 也没有可见性保证，这就导致并发问题了。
第二段错误原因：
加锁本质就是在锁对象的对象头中写入当前线程id，但是synchronized (new object())每次在内存中都是新对象，所以加锁无效。
问：刚刚的例子都是多个锁保护一个资源，这样百分百是不行的。那么一个锁保护多个资源，就一定可以了吗？
答：如果多个资源彼此之间是没有关联的，那可以用一个锁来保护。如果有关联的话，那是不行的。比如说银行转账操作，你给我转账，我账户多100，你账户少100，我不能用我的锁来保护你，就像现实生活中我的锁是不能保护你的财产的。
划重点！要区分多个资源是否有关联！但是一个锁保护多个没关联的资源，未免性能太差了哦，比如我听歌和玩游戏可以同时进行，你非得让我做完一个再做另一个，岂不是要双倍时间。所以即使一个锁可以保护多个没关联的资源，但是一般而已，会各自用不同的锁，能够提升性能。这种锁还有个名字，叫细粒度锁。
问：刚刚说到银行转账的案例，那么假如某天在某银行同时发生这样一个事，柜员小王需要完成a账户给b账户转账100元，柜员小李需要完成b账户给a账户转账100元，请问如何实现呢？
答：其实用两把锁就实现了，转出一把，转入另一把。只有当两者都成功时，才执行转账操作。
public static void main(string[] args) throws interruptedexception {
account a = new account(200); //a的初始账户余额200
account b = new account(300); //b的初始账户余额200
thread threada = new thread(()->{
try {
transfer(a,b,100);
} catch (interruptedexception e) {
e.printstacktrace();
}
});
thread threadb = new thread(()->{
try {
transfer(b,a,100);
} catch (interruptedexception e) {
e.printstacktrace();
}
});
threada.start();
threadb.start();
}
static void transfer(account source,account target, int amt) throws interruptedexception {
synchronized (source) {
log.info("持有锁{} 等待锁{}",source,target);
synchronized (target) {
if (source.getbalance() > amt) {
source.setbalance(source.getbalance() - amt);
target.setbalance(target.getbalance() + amt);
}
}
}
}
至此，恭喜你，一波问题解决了，可是遗憾的告诉你：又导致了另一个bug。这段代码是有可能发生死锁的！并发编程中要注意的东西可真是多哟。咱们先把死锁这个名词记住！持续关注【胖滚猪学编程】公众号！在我们后面的文章中找答案！
如何保证原子性
现在我们已经知道互斥锁可以保证原子性，也知道了如何使用synchronized来保证原子性。但synchronized 并不是java中唯一能保证原子性的方案。
如果你粗略的看一下j.u.c(java.util.concurrent包)，那么你可以很显眼的发现它俩：
一个是lock包，一个是atomic包，只要你英语过了四级。。我相信你都可以马上断定，它们可以解决原子性问题。
由于这两个包比较重要，可以后续再关注学习。