目录
写在前面
一道简单线程安全题，不知道有多少人答不上来
实验：并发的自增运算
++ 运算的原理
Java 的原子操作类
写在最后
疯狂创客圈 Java 死磕系列
疯狂创客圈 Java 分布式聊天室【 亿级流量】实战系列之 -17【 博客园 总入口 】
源码IDEA工程获取链接：Java 聊天室 实战 源码
写在前面
大家好，我是作者尼恩。
目前正在组织 疯狂创客圈的几个兄弟，从0开始进行高并发的100级流量（不是用户）聊天器的实战。
在设计客户端之前，发现一个非常重要的基础知识点，没有讲到。这个知识点就是Java并发包。
由于Java并发包将被频繁使用到，所以不得不停下来，先介绍一下。
一道简单线程安全题，不知道有多少人答不上来
尼恩作为技术主管，常常组织组织技术面试，而且往往是第二面。
某次面试，候选人是从重庆一所211大学毕业了一年的初级Java工程师，暂且简称Y君。
在尼恩面试前，Y君已经过了第一关，通过了PM同事的技术面试，PM同事甚至还反馈说Y君的继承不错。理论上，Y君的offer已经没有什么悬念了。
于是，尼恩想前面无数次面试一样，首先开始了多线程方面的问题。
先上来就是砸出一个古老的面试问题：
程序为什么要用多线程，单线程不是很好吗？
多线程有什么意义？
多线程会带来哪些问题，如何解决？
++操作是线程安全的吗？
乖乖，Y君的答案，令人出人意料。
答曰：“我从来没有用过多线，不是太清楚多线程的意义，也不清楚多线程能带来哪些问题”。
乖乖，看一看Y君的简历，这个又是一个埋头干活，被增删改查坑害了的小兄弟！
这已经不是第一个了，我已经记不清楚，有多少面试的兄弟，搞不清楚一这些非常基础的并发编程的知识。
单体WEB应用的时代，已经离我们远去了。 微服务、异步架构的分布式应用时代，已经全面开启。
对于那些面试失败的兄弟，为了提升他们的水平，尼恩都会给他提一个善意的建议。让他们去做一个简单的并发自增运算的实验，看看自增运算是否线程安全的。
实验：并发的自增运算
使用10条线程，对一个共享的变量，每条线程自增100万次。看看最终的结果，是不是1000万？
完成这个小实验，就知道++运算是否是线程安全的了。
实验代码如下：
/**
* Created by 尼恩 at 疯狂创客圈
*/
package com.crazymakercircle.operator;
import com.crazymakercircle.util.Print;
/**
* 不安全的自增 运算
*/
public class NotSafePlus
{
public static final int MAX_TURN = 1000000;
static class NotSafeCounter implements Runnable {
public int amount = 0;
public void increase() {
amount++;
}
@Override
public void run() {
int turn = 0;
while (turn < MAX_TURN) {
++turn;
increase();
}
}
}
public static void main(String[] args) throws InterruptedException {
NotSafeCounter counter=new NotSafeCounter();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(counter);
thread.start();
}
Thread.sleep(2000);
Print.tcfo("理论结果：" + MAX_TURN * 10);
Print.tcfo("实际结果：" + counter.amount);
Print.tcfo("差距是：" + (MAX_TURN * 10 - counter.amount));
}
}
运行程序，输出的结果是：
[main|NotSafePlus:main]：理论结果：10000000
[main|NotSafePlus:main]：实际结果：9264046
[main|NotSafePlus:main]：差距是：735954
也就是说，并发执行后，总计自增1000万次，结果少了70多万次，差距是巨大的，在10%左右。
当然，这只是一次结果，每一次运行，差距都是不同的。大家可以动手运行体验一下。
从结果可以看出，自增运算符不是线程安全的。
++ 运算的原理
自增运算符，至少包括三个JVM指令
从内存取值
寄存器增加1
存值到内存
这三个指令，在JVM内部，是独立进行的，中间完全可能会出现多个线程并发进行。
比如：当amount=100是，有三个线程读同一时间取值，读到的都是100，增加1后结果为101，三个线程都存值到amount的内存，amount的结果是101，而不是103。
JVM内部，从内存取值，寄存器增加1，存值到内存，这三个操作自身是不可以再分的，这三个操作具备原子性，是线程安全的，也叫原子操作。两个、或者两个以上的原子操作合在一起进行，就不在具备原子性。比如先读后写，那么就有可能在读之后，这个变量被修改过，写入后就出现了数据不一致的情况。
Java 的原子操作类
对于每一种基本类型，在java 的并发包中，提供了一组线程安全的原子操作类。
对于Integer类型，对应的原子操作类是AtomicInteger 类。
java.util.concurrent.atomic.AtomicInteger
使用 AtomicInteger类，实现上面的实验，代码如下：
import java.util.concurrent.atomic.AtomicInteger;
/**
* 安全的 ++ 运算
*/
public class SafePlus
{
public static final int MAX_TURN = 1000000;
static class NotSafeCounter implements Runnable {
public AtomicInteger amount =
new AtomicInteger(0);
public void increase() {
amount.incrementAndGet();
}
@Override
public void run() {
int turn = 0;
while (turn < MAX_TURN) {
++turn;
increase();
}
}
}
public static void main(String[] args) throws InterruptedException {
NotSafeCounter counter=new NotSafeCounter();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(counter);
thread.start();
}
Thread.sleep(2000);
Print.tcfo("理论结果：" + MAX_TURN * 10);
Print.tcfo("实际结果：" + counter.amount);
Print.tcfo("差距是：" + (MAX_TURN * 10 - counter.amount.get()));
}
}
运行代码，结果如下；
[main|NotSafePlus:main]：理论结果：10000000
[main|NotSafePlus:main]：实际结果：10000000
[main|NotSafePlus:main]：差距是：0
这一次，10条线程，累加1000w次，结果是1000w。
看起来，如果需要线程安全，需要使用Java并发包中的原子类。
写在最后
下一篇：Netty 中的Future 回调实现与线程池详解。这个也是一个非常重要的基础篇。
疯狂创客圈 Java 死磕系列
Java (Netty) 聊天程序【 亿级流量】实战 开源项目实战
Netty 源码、原理、JAVA NIO 原理
Java 面试题 一网打尽
疯狂创客圈 【 博客园 总入口 】https://www.cnblogs.com/crazymakercircle/p/10089113.html
