Java并发编程实战

未分类

第一章 简介

最开始的计算机只能运行一个程序，操作系统的出现带来了进程，提高了资源利用率，公平性和便利性。而线程则进一步细分了进程。

计算机 -> 操作系统(进程) -> 线程
  1         n         n*m

但凡做事高效的人，总能在串行性和异步性之间找到合理的平衡，对于程序也是如此。

• 线程也被称为轻量级进程，在大多数现代操作系统中，都是以进程为基本的调度单位。

线程共享进程的变量等资源，如果没有明确的协同机制，那么当一个线程正在使用某个变量时，另一个线程可能同时访问这个变量，这将造成不可预测的结果。

线程的优势

• 发挥多处理器的强大能力
  现在的计算机都是多核的，一个单线程的进程只能使用一个cpu资源，那么如果是双核的计算机，只能占有50%的资源，如果是100个处理器的系统上，将有99%的资源无法使用！

• 建模的简单性
  将任务分成子任务，然后放在不同的线程中执行，比一个冗杂的大型任务更易于编写，错误更少，也更容易测试，每个工作流在一个单独的线程中运行，并在特定的同步位置进行交互。

• 异步事件的简化处理

• 响应更灵敏的用户界面

线程的风险

• 安全性问题
  因为多个线程中的操作执行顺序是不可预测的，并且线程共享进程中的变量，这是一种便利：这种方式比其他线程间通信机制更容易实现数据共享。但也带来了极大的风险：无法预料的数据变化。
• 活跃性问题
  活跃性问题在单线程中就是无限循环问题，在多线程中就是死锁，A在等待B释放资源，而B永远都不释放，那么A就会永久地等待下去。并且，导致活跃性问题的错误是难以分析的，他们并不总是能够重现。
• 性能问题
  虽然线程能够提升程序的性能，但频繁的挂起活跃线程而运行另一个线程，就会频繁的出现上下文切换操作，会带来极大的开销。

线程无处不在

框架中可能也会创建线程，JVM启动时，它将为JVM的内部任务，垃圾收集器，终结操作等创建后台线程，并创建一个主线程来运行main方法。

第二章 线程安全性

当多个线程访问某个类时，这个类始终都能表现出正确的行为，那么就称这个类是线程安全的。

• 无状态对象一定是线程安全的
  一个类它既不包含任何域，也不包含任何对其他类中域的引用，那它是无状态的，计算过程中的临时状态仅存在于线程栈上的局部变量中，并且只能由正在执行的线程访问。

原子性 Atomic

一个无状态类，只是加了一个count值，在每次调用这个类的时候count++，它就不是线程安全的了：count++并非一个原子操作，它包含了读取修改写入三个操作，每次操作都依赖于前面的状态。
在并发编程中，由于不恰当的执行时序而出现不正确的结果是一种非常重要的情况，被称为竞态条件。

• 竞态条件
  最常见的竞态条件就是“先检查后执行”操作，即通过一个可能失效的观测结果来决定下一步的动作。
  如你去找星巴克的朋友，进入A店发现他不在，你只好去B找，但是也不在，你可能会怀疑他失约了，但是在你离开A店的时候，你对A的观测无效，他可能从后门进来了，但你不知道。你们只能来来回回找，可能最后一天都没碰上面。
  如延迟初始化（单例模式）

public class LazyInitRace{
    private ExpensiveObject instance = null;
    public ExpensiveObjcet getInstance(){
        if(instance == null) // 如果两个线程同时检查怎么办？
            instance = new ExpensiveObject();
        return instance;
    }
}
如果两个线程同时执行getInstance方法，而且都觉得还未创建，又分别都创建了，那可能会得到两个instance！
这可不是我们想要的“单例模式”

• 复合操作
  在实际情况中，应该尽可能的使用现有的线程安全对象来管理类的状态，如将count改成AtomicLong类型，并通过其的incrementAndGet（）方法来实现自增，因为AtomicLong是线程安全类，就不会出现问题。

加锁机制

光使用线程安全类是不够的，当更新某个变量时，需要在同一个原子操作中对其他变量同时进行更新。

• 内置锁 Synchronized Block
  每个Java对象都可以用做一个实现同步的锁，这些锁被称为内置锁或监视器锁。线程在进入同步代码块之前会自动获得所，并且在退出同步代码块时自动释放锁。
  内置锁是一种互斥锁。只要加synchronized关键字即可。但是，因为这种方法过于极端，多个客户端无法同时使用代码块，性能非常低。
• 重入
  如果某一个线程试图获得一个由其他线程持有的锁，发出请求的线程就会阻塞，但是，如果是自己的锁，那么就会成功，同时计数器+1，计数器为0时才释放锁。
  因此我们可以实现子类重写父类的synchronized方法，并且调用父类的synchronized方法，如果不可重入，则会产生死锁，因为获取锁后又再次获取锁，而当前锁正在被自己持有呢。

用锁来保护状态

• 对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，在这种情况下，我们称状态变量是由这个锁保护的。

• 每个共享的和可变的变量都应该只有一个锁来保护，从而使维护人员知道是哪一个锁。

当获取与对象关联的锁时，并不能组织其他线程访问该对象，只能阻止其他线程获得同一个锁，每个对象都有一个内置锁只是为了免去显式地创建锁对象。

一种常见的加锁约定是，将所有的可变状态都封装在对象内部，并通过对象的内置锁对所有访问可变状态的代码路径进行同步。在许多线程安全类中都是用了这种模式，如Vector和其他的同步集合类。

如果不加区别的滥用synchronized，可能会导致更多的同步。

• 如果每个方法都是同步方法，如Vector，但是复合操作也不一定是原子的，要把多个操作合并为一个复合操作，还是需要额外的加锁机制。

 if(!vector.contains(element))
    vector.add(element);
虽然contains和add都是原子方法，但是这个操作中仍然存在竞态条件。

活跃性与性能

• 不良并发应用程序（Poor Concurrency）：可同时调用的数量，不仅受到可用处理资源的限制，还受到应用程序本身结构的限制。

我们应该缩小同步代码块的作用范围，但是不要太小，不要将本应该是原子的操作拆分到多个同步代码块中。尽量将不影响共享状态且执行时间较长的操作从同步代码块中分离出去。

当执行时间较长的计算或者可能无法完成的操作时（网络IO操作，控制台IO操作），一定不要持有锁。

第三章 对象的共享

第二章强调了原子性，即不能有两个线程修改同一个变量。而同步还有另一个重要的方面：可见性。我们希望当一个确保一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

• 主线程的变量是否在其他线程中可见是未知的。

public class NoVisibility{
    private static boolean ready;
    private static int number;
    private static class ReaderThread extends Thread{
        public void run(){
            while(!ready) // ready在被修改为true前线程阻塞
                Thread.yield();
            System.out.println(number);
        }
    }
    public static void main(String[] args){
        new ReaderThread().start();
        number = 42;
        ready = true;
    }
}

程序有这么几种情况：
1.一直循环下去，主线程的两个修改一个都没看见。
2.输出0，只有ready的修改被看见了。因为重排序的原因，ready的修改在number之前。
3.输出42，两个都被看见了。

这三种情况是哪一种我们并无法知道，这就是非同步带来的可见性问题。

• 这是失效数据问题，当读线程读ready变量时，可能会看到一个已经失效的值。除非在每次访问变量时都使用同步，更糟糕的是，失效值可能不会同时出现，一个线程可能获得某个变量的最新值，而获得另一个变量的失效值。

  ---

• Java内存模型要求，变量的读取操作和写入操作都必须是原子操作，但是long和double会将变量分成两个32位的变量，因此如果在多线程程序中使用共享且可变的long和double变量是不安全的，除非用volatile声明或者使用锁进行保护。

加锁与可见性

加锁的含义不仅仅局限于互斥行为，还包括内存可见性。为了确保所有线程都能看到共享变量的最新值，所有执行操作的线程都必须在同一个锁上同步。

• 较弱的同步机制 volatile
  把变量声明成volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其它内存一起重排序，在读取volatile类型的变量时总会返回最新写入的值。
  在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile是一种比synchronized更加轻量级的同步机制。
• 加锁机制既可以确保可见性也可以确保原子性，而volatile变量只能确保可见性。

发布与逸出

发布就是使对象能够在当前作用域之外的代码中使用。
逸出就是指某个不该发布的对象被发布。

线程封闭

如果仅在单线程中访问数据，就不需要同步，这种技术被称为线程封闭（Thread Confinement）。这是实现线程安全性的最简单方式之一。
在Swing和JDBC中大量使用了线程封闭技术。

• Ad-hoc线程封闭
  非常脆弱，尽量不要用。
• 栈封闭
  只有通过局部变量才能访问对象。
• ThreadLocal类
  https://www.cnblogs.com/ldq2016/p/9041856.html
  维持线程封闭性的一个更规范的方法，能使线程中的某个值与保存值的对象关联起来。
  使用ThreadLocal，每个线程都会有一份自己的变量拷贝。当某个线程初次调用ThreadLocal.get方法时，就会调用initialValue来获取初始值。可以看做ThreadLocal中包含了Map对象，里面保存了特定该线程的值，当线程终止后，这些值会作为垃圾回收。

不变性

• 不可变对象一定是线程安全的。
• 满足以下条件的对象是不可变的：
  对象创建后其状态就不能被修改。
  对象的所有域都是final类型。
  对象是正确创建的（无this引用逸出）。

安全发布

• 任何线程都可以在不需要额外同步的情况下安全地访问不可变对象，即使在发布这些对象时没有使用同步。

• 要安全地发布一个对象，对象的引用以及对象的状态必须同时对其他线程可见。一个正确构造的对象可以通过以下方式来安全的发布：
  在静态初始化函数中初始化一个对象引用。
  将对象的引用保存到volatile类型的域或者AtomicReferance对象中。
  将对象的引用保存到某个正确构造对象的final类型域中。
  将对象的引用保存到一个由锁保护的域中。

• 在没有额外的同步的情况下，任何线程都可以安全地使用被安全发布的事实不可变对象。

• 对象的发布需求取决于它的可变性：
  不可变对象可以通过任意机制来发布。
  事实不可变对象必须通过安全方式来发布。
  可变对象必须通过安全方式来发布，并且必须是线程安全的或者由某个锁保护起来。

• 使用和共享对象的一些实用策略：
  线程封闭，只读共享，线程安全共享，保护对象。

对象的组合

我们希望能用一些现有的线程安全组件组合起来，组合为更大规模的组件或程序，这些模式能够使得一个类更容易成为线程安全的，并且维护这些类时不会无意中破坏类的安全性保证。

• 设计线程安全类的过程中需要三个基本要素：
  找出构成对象状态的所有变量。
  找出约束状态变量的不变性条件。
  建立对象状态的并发访问管理策略。

如果对象的所有域都是基本类型的变量，这些域就是对象的全部状态。
如果对象的域引用了其他对象，那么该对象的状态将包含被引用对象的域。比如LinkedList的状态就包括该链表中所有节点对象的状态。

基础构建模块

同步容器类