java并发编程

一、关于并发

1. 并发是什么？
   • 并发是指在同一时间间隔内，有多个程序处于运行状态。当然，同一时刻只有一个程序在运行。与之对应的是并行，并行是指同一时刻有多个程序同时执行（宏观上）
2. 为什么需要并发？
   • 为了提高系统的资源利用率 和 吞吐量。就好比全班需要填表时，可以发给每个人，然后填完之后在收起来，这样的效率远比一个一个的发，然后等第一个人填完了再发给第二人填写要快的多
3. 什么是线程安全？
   • 线程作为独立调用的单位，当使用线程实现并发时，由于处理机的调度，可能存在线程安全问题。那什么是线程安全呢，定义为：当多个线程访问某个类是，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，这个类都能表现出正确的行为，则称这个类是线程安全的。

二、并发编程中的3个概念

1.原子性

• 定义：一个操作要么全部操作 要么都不执行
• 类似于 自增（++） 的操作，就不是原子的，因为这个操作实际上是一个“读取-修改-写入”的操作序列，其结果依赖于之前的状态。还有就是竞态条件（先检查后执行—if）非原子操作

2.可见性（同步）

• 定义：可见性是指当一个线程修改了共享变量的值后，其他线程能够立即得知这个修改。为了确保多个线程之间对内存的写入操作的可见性，必须使用同步机制。在没有同步的情况下，编译器 或 处理器 都可能对操作的执行顺序进行调整。
• volatile 变量，是一种稍弱的同步机制，它能确保变量的更新操作通知到其他线程。
  1. 非volatile变量为什么会存在不可见问题？
     • 因为变量存储在主内存中，当一个线程需要这个变量时，它会从主内存中拷贝一份到自己线程内存中。如果这时，这个线程对它进行了修改，其他线程又访问了这个变量时，也会去主内存进行拷贝，就会导致失效数据。
  2. volatile 变量是怎么保证可见性的呢？
     • 被 volatile 修饰的变量，每次在自己线程中使用时，都会从主内存中刷新自己的值（如果发生了改变），当被线程修改了值后，又会立即返回主内存中，把主内存中的值进行刷新。底层实现是通过内存屏障（lock前缀指令）实现的
  3. 那么 volatile 变量能保证原子性吗？
     • volatile 变量是不能保证原子性的

3.有序性

• 有序性是指数据不相关的变量在并发的情况下，实际执行的结果和单线程的执行结果是一样的，不会因为重排序而导致结果未知，volatile、final、synchronized、显示锁可以保证有序性

三、同步机制

1.内置锁

• 每个java对象都可以用做一个实现同步的锁，这些所被称为内置锁。获得内置锁的唯一途径就是进入这个锁保护的同步代码块或方法（被 synchronized 修饰的代码块或方法）。
  • 被synchronized 修饰的静态方法，锁对象为当前 Class 对象
  • 被 synchronized 修饰一般方法，锁对象为当前对象
  • 同步代码块的锁对象为自己指定的对象
• synchronized 是 JVM 的内置属性，JVM对此进行了优化，比如：
  • 锁消除优化（去除一些不会发生竞争的锁）；
  • 增加锁粒度（将附近的同步代码块用同一个锁合并起来，减少了同步的开销）；
  • 找出不会发布到堆的本地对象引用，去除锁获取操作。（也就是线程封闭）
• 内置锁是可重入的，为什么？
  • 重入是指：如果线程试图获取一个已经由它自己持有的锁，那么这个请求就会成功。
  • 为什么是可重入的？如下代码，当调用子类的 doSomething方法时，获取了锁（当前实例），然后调用父类的方法，如果不是可重入的，则会产生死锁，因为无法获得父类上的锁（也是当前实例，因为这个锁已经被持有，从而线程会永远停顿下去）

    
    public class Widget{
    
    public synchronized void doSomething(){
    
        ...
    
    }
    
    }
    
    public class LoggingWidget extends Widget{
    
    public sychronized void doSomething{
    
        super.doSomething();
    
    }
    
    }
    

2.显示锁Lock

a.关于Lock

• Lock 是java中的一个接口，其提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作。与synchronized 相同的是 互斥性 与 内存可见性。当然，它也是可重入的。java.util.concurrent.locks包中有很多实现类，常用的有 ReentrantLock、ReadWriteLock，其实现都是依赖于 java.util.concurrent.AbstractQueuedSynchronizer 类
• 下面是 Lock 接口 定义的方法

  
  public interface Lock{
  
  void lock();
  
  void lockInterruptily() throws InterruptedException;
  
  boolean tryLock();
  
  boolean tryLock(long time,TimeUnt unit) throws InterruptedException;
  
  void unlock();
  
  Condition newCondition();
  
  }
  
  /**
  
  其中前面4 个方法都是用来获取锁的，unLock（）方法是用来释放锁的：
  
  1.lock（）方法是用来获取锁的，如果锁已被其他线程获取，则进行等待。使用lock必须在try-catch 块中进行，释放锁必须在finally 块中进行，因为如果抛出了异常，这个锁永远都不会被释放。
  
  2.tryLock（）：请求加锁，如果加锁不成功返回false，不会发生阻塞
  
  3.tryLock（long time，TimeOut unit）throws InterruptedException：请求加锁，如果加锁不成功会在规定的时间内阻塞，超时后会返回，支持中断
  
  4.lockInterruptibly（）throws InterruptedException：请求加锁，如果请求不到锁会发生阻塞，在阻塞过程中允许中断
  
  */
  

b.关于AbstractQueueSynchronizer

• 在java.util.concurrent 中许多可阻塞类，例如 ReentrantLock、Semaphore、ReentrantReadWriteLock、CountDownLatch、SynchronousQueue 和 FutureTask等都是基于 AQS 构建的。

3.在synchronized
和 ReentrantLock 的选择

• synchronized 与 lock 锁的区别：
  1. synchronized 是 基于软件层面，JVM 内置的锁，而 Lock是基于CPU指令的
  2. synchronized 是基于块结构的，而 Lock 可以有更小的粒度
  3. synchronized 是不可中断的，而 Lock是可中断的
  4. synchronized 不用自己释放锁，而lock需要显示释放锁（在finally代码块中）
• 由于 synchronized 是 JVM 的内置锁，所以对它可进行的干预很少，甚至不需要自己来释放锁。除此之外， JVM还对内置锁做了一些优化，所以建议只有在内置锁无法满足需求的情况下，才选择使用 ReentrantLock。比如：可定时、可轮询、可中断的锁获取操作，以及非块结构（相当于ConcurrentHashMap 中的锁分段）。

4.锁的劣势

1. 当线程恢复执行时，必须等待其他线程执行完它们的时间片以后，才能被调度指向，在挂起和恢复线程等过程中存在很大的开销，并且通常存在着较长时间的中断
2. 当一个线程正在等待锁时，它不能做任何其他事情，必须等待锁释放

5.非阻塞同步机制

• 基于锁的劣势，处理器提供了一种类似于 volatile变量的机制同时还支持原子的更新操作（测试并设置，比较并交换，获取并递增）。这种方法采用的是乐观的方法，意思就是如果在操作过程中，有其他线程的干扰，就重试。
• 比较并交换 CAS：首先从V中读取值A，并根据A计算新值B，然后再通过CAS以原子方式将V中的值由A变成B（只要在这段期间没有任何线程将 V的值修改为其他值）。这种方式的主要缺点是：它将是调用者处理竞争问题（重试、回退、放弃），并且在高并发的情况下，失败的几率大大增加。
• 在java中，原子变量类就直接利用了底层的并发原语（CAS）来维持线程的安全性

四、避免使用同步的方式

1. 线程封闭：也就是在单线程内访问数据
   • 局部变量，其封闭在执行的线程中，位于线程的栈中，其他线程无法访问这个栈
   • ThreadLocal 类，这个类能使线程中的某个值与保存值的对象关联起来，其可以防止对可变的单实例变量或全局变量进行共享。每个线程中有一个 localVariable 变量，这个变量是 一个threadLocalMap 变量，当设置值的时候会获取当前线程的 Map，然后把当前 threadLocal 添加进去，key为当前 threadLocal，value为 资源，然后获取的时候也是获取当前对象的Map，然后进行获取，从而屏蔽了线程的私有变量
2. 不可变对象：因为不可变对象一定是线程安全。不可变对象必须满足一下条件：
   • 对象创建以后其状态就不能修改
   • 对象的所有域都是final类型
   • 对象是正确创建的（在对象的创建期间，this引用没有逸出）

五、并发容器 & 同步工具类

1.并发容器

• Queue：
  • ConcurrentLInkedQueue：先进先出的并发队列
  • PriorityQueue：是一个非并发的优先队列，Queue上的操作不会阻塞，如果队列为空，获取元素的操作将会返回空值。是由LinkedList实现
  • BlockingQueue：可阻塞队列，如果队列为空，获取操作将一直阻塞，直到队列出现一个 可用的元素；如果队列已满，则插入元素的操作将一直阻塞，直到队列出现可用的空间。阻塞队列一般用于生产者-消费者模式
    • LinkedBlockingQueue：基于链表
    • ArrayBlockingQueue：基于数组
    • PriorityBlockingQUeue：按照优先级排序的队列
    • SynchronousQueue：其维护一组线程直接交付给处理线程，从而降低了将数据从生产者移动到消费者的延迟
• Concurrent
  • CopyOnWriteArrayList| CopyOnWriteArraySet：写入时复制，也就是在每次修改时，都会创建并重新发布一个新的容器副本，因此写操作花费很大，但是在访问对象不需要进行同步
  • ConcurrentMap：是 Map的同步容器类
• Deque：Deque是对Queue的扩展，它是一个双端队列，实现了在队列头和队列尾的高效插入和移除

  2.同步工具类

• 闭锁

  闭锁是一种同步工具类，可以延迟线程的进度直到其到达终止状态。闭锁可以用来确保某些活动直到其他活动都完成后才继续执行，用于等待事件

  CountDownLatch ：使一个或多个线程等待一组事件发生，countDown方法递减计数器（表示还需等待多少事件发生），而await方法等待计数器达到零

• FutureTask — 可用于实现缓存，用于检查某项任务是否已经开始，而不是检查是否完成

  Future.get 的行为取决于任务的状态，如果任务已经完成，那么 get会立即返回结果，否则get 将阻塞直到任务进入 完成状态，然后返回结果或者抛出异常。FutureTask 将计算结果从执行计算的线程传递到获取这个结果的线程

• 信号量

  计数信号量用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量。技术信号量还可以用来实现某种资源池，或者对容器施加边界

  Semaphore 中管理者一组虚拟的许可，许可的初始数量可通过构造函数来指定，在执行操作时可以首先获得许可（只要还有剩余的许可 — 阻塞），并在使用后释放许可。当初始值为1 的 S恩吗炮轰热二值信号量可以用做互斥体，并具备不可重入的加锁（相当于的加锁）

  可以用做 数据库连接池 、 可以使用Semaphore 将任何一种容器变成有界阻塞容器

• 栅栏 — 等待过后还要做其他事情

  闭锁是一次性对象，一旦进入终止状态，就不能被重置

  栅栏：所有线程必须同时到达栅栏位置才能继续执行，用于等待其他线程，等待过后还要做其他事情，用于实现一些协议

  ①CyclicBarrier:等待全部线程狙击，栅栏打开，线程被释放，栅栏被重置。线程如未全部通过，则线程将全部终止并抛出 BrokenBarrierException ，若成功通过，则 await将Wie每个线程返回一个唯一的到达索引号。

  完成了前一步的所有操作才可以进入下一步

  ②另一种形式的栅栏式 Exchanger ，它是一种两方栅栏，各方在栅栏位置上交换数据，当两个线程通过 Exchanger 交换对象时，这种交换就把这两个对象安全的发布给另一方。

  a. 当缓冲区被填满时，有填充任务进行交换，当缓冲区为空时，有清空任务进行交换

  b. 不仅当缓冲被填满时进行交换，并且当缓冲被填充到一定程度并保持一定时间后也进行交换

参考资料：

http://www.cnblogs.com/dolphin0520/p/3923167.html