混混噩噩看了很多多线程的书籍，一直认为自己还不够资格去阅读这本书。有种要高登大堂的感觉，被各种网络上、朋友、同事一顿外加一顿的宣传与传颂，多多少少再自我内心中产生了一种敬畏感。2月28好开始看了之后，发现，其实完全没这个必要。除了翻译的烂之外（一大段中文下来，有时候你就会骂娘：这tm想说的是个shen me gui），所有的，多线程所必须掌握的知识点，深入点，全部涵盖其中，只能说，一书在手，万线程不愁那种！当然，你必须要全部读懂，并融汇贯通之后，才能有的效果。我推荐，看这本书的中文版本，不要和哪一段的冗长的字句在那过多的纠缠，尽量一段一段的读，然后获取这一段中最重要的那句话，否则你会陷入中文阅读理解的怪圈，而怀疑你的高中语文老师是不是体育老师客串的！！我举个例子：13页第八段，我整段读了三遍硬是没想明白前面那么多的文字，是干什么用的，就是最后一句话才是核心：告诉你，线程安全性，最正规的定义应该是什么！（情允许我，向上交的几个翻译此书的，所谓的“教授”致敬，在你们的引领下，使我们的意志与忍受力更上了一个台阶，人生更加完美！）
一、多线程开发所要平衡的几个点
看了很多次的目录，外加看了第一部分，发现，要想做好多线程的开发，无非就是平衡好以下的几点
- 安全性
- 活跃性
- 无限循环问题
- 死锁问题
- 饥饿问题
- 活锁问题（这个还没具体的了解到）
- 性能要求
- 吞吐量的问题
- 可伸缩性的问题
二、多线程开发所要关注的开发点
要想平很好以上几点，书中循序渐进的将多线程开发最应该修炼的几个点，娓娓道来：
- 原子性
- 先检查后执行
- 原子类
- 加锁机制
- 可见性
- 重排
- 非64位写入问题
- 对象的发布
- 对象的封闭
- 不变性
在一本国人自己写的，介绍线程工具api的书中，看到了这么一句话：外练原子，内练可见。感觉这几点如果在多线程中尤为重要。我在有赞，去年还记得上线多门店的那天凌晨，最后项目启动报一个类加载的错误，一堆人过来看问题，基德大神站在攀哥的后面，最后淡淡的说了句：已经很明显是可见性问题了，加上volatile，不行的话，我把代码吃了！！可以见得，多线程这几个点，在“居家旅行”，生活工作中是多么的常见与重要！不出问题不要紧，只要一出，就会是头痛的大问题，因为你根本不好排查根本原因在这。所以我们需要平时就练好功底，尽量避免多线程问题的出现！而不是一味的用框架啊用框架、摞代码啊摞代码！
三、原子性下面的安全问题
1. 下面代码有什么问题呢？
public class UnsafeConuntingFactorizer implements Servlet{
private long count = 0;
private long getCount(){
return count;
}
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
BigInteger[] factors = factor(i);
++count;
encodeIntoResponse(resp,factor);
}
}思考：如何让一个普普通通的类变得线程安全呢？一个类什么叫做有状态，而什么又叫做无状态呢？
2. 解答上面代码
- 一个请求的方法，实例都是一个，所以每次请求都会访问同一个对象
- 每个请求，使用一个线程，这就是典型的多线程模型
- count是一个对象状态属性，被多个线程共享
++count并非一次原子操作（分成：复制count->对复制体修改->使用复制体回写count，三个步奏）- 多个线程有可能多次修改count值，而结果却相同
3. 使用原子类解决上面代码问题
public class UnsafeConuntingFactorizer implements Servlet{
private final AtomicLong count = new AtomicLong(0);
private long getCount(){
return count.get();
}
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
BigInteger[] factors = factor(i);
count.incrementAndGet();//使用了新的原子类的原子方法
encodeIntoResponse(resp,factor);
}
}4. 原子类也不是万能的
//在复杂的场景下，使用多个原子类的对象
public class UnsafeConuntingFactorizer implements Servlet{
private final AtomicReference<BigInteger> lastNumber
= new AtomicReference<BigInteger>();
private final AtomicReference<BigInteger[]> lastFactors
= new AtomicReference<BigInteger[]>();
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
if(i.equals(lastNumber.get())){//先判断再处理，并没有进行同步，not safe！
encodeIntoResponse(resp,lastFactors.get());
}else{
BigInteger[] factors = factor(i);
lastNumer.set(i);
lastFactors.set(factors);
encodeIntoResponse(resp, factors);
}
}
}思考：什么叫做复合型操作？
5. 先列举一个我们常见的复合型操作
public class LazyInitRace {
private ExpensiveObject instace = null;
public ExpensiveObject getInstace(){
if(instace == null){
instace = new ExpensiveObject();
}
return instace;
}
}看好了，这就是我们深恶痛绝的一段代码！如果这段代码还分析不了的，对不起，出门左转~
6. 提高“先判断再处理”的警觉性
- 如果没有同步措施，直接对一个状态进行判断，然后设值的，都是不安全的
- if操作和下面代码快中的代码，远远不是原子的
- 如果if判断完之后，接下来线程挂起，其他线程进入判断流程，又是同样的状态，同样进入if语句块
- 当然，只有一个线程执行的程序，请忽略（那还叫能用的程序吗？）
7. 性能的问题来了
//在复杂的场景下，使用多个原子类的对象
public class UnsafeConuntingFactorizer implements Servlet{
private final AtomicReference<BigInteger> lastNumber
= new AtomicReference<BigInteger>();
private final AtomicReference<BigInteger[]> lastFactors
= new AtomicReference<BigInteger[]>();
//这下子总算同步了！
public synchronized void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
if(i.equals(lastNumber.get())){//先判断再处理，并没有进行同步，not safe！
encodeIntoResponse(resp,lastFactors.get());
}else{
BigInteger[] factors = factor(i);
lastNumer.set(i);
lastFactors.set(factors);
encodeIntoResponse(resp, factors);
}
}
}思考：有没有种“关公挥大刀，一砍一大片”的感觉？
8. 上诉代码解析
- 加上了
synchronized关键字的确解决了多线程访问，类安全性问题 - 可是每次都是一个线程进行计算，所有请求变成了串行
- 请求量低于100/s其实都还能接受，可是再高的话，这就完全有问题的代码了
- 性能问题，再网络里面，是永痕的心病~
9. 一段针对原子性、性能问题的解决方案
//在复杂的场景下，使用多个原子类的对象
public class CacheFactorizer implements Servlet{
private BigInteger lastNumber;
private BigInteger[] lastFactors ;
private long hits;
private long cacheHits;
public synchronized long getHits(){
return hits;
}
public synchronized double getCacheHitRadio(){
return (double) cacheHits / (double) hits;
}
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
BigInteger[] factors = null;
synchronized (this){
++hits;
if(i.equals(lastNumber)){
++cacheHits;
factors = lastFactors.clone();
}
}
if (factors == null){
factors = factor(i);
synchronized (this){
lastNumer = i;
lastFactors = factors.clone();
}
}
encodeIntoResponse(resp, factors);
}
}在修改状态值的时候，才进行加锁，平时对状态值的读操作可以不用加锁，当然，最耗时的计算过程，也是要同步的，这种情况下，才会进一步提高性能。
