一 并发编程的挑战

1、上下文切换

• 即使是单核处理器也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现
  这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停地切
  换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒（ms）。
• CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个
  任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这
  个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换
• 这就像我们同时读两本书，当我们在读一本英文的技术书时，发现某个单词不认识，于是
  便打开中英文字典，但是在放下英文技术书之前，大脑必须先记住这本书读到了多少页的第
  多少行，等查完单词之后，能够继续读这本书。这样的切换是会影响读书效率的，同样上下文
  切换也会影响多线程的执行速度。

1.1如何减少上下文切换

减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程。

• 无锁并发编程。多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一
  些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据。
• CAS算法。Java的Atomic包使用CAS算法来更新数据，而不需要加锁。
• 使用最少线程。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这
  样会造成大量线程都处于等待状态。
• 协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。

实战

• 第一步：用jstack命令dump线程信息，看看pid为3117的进程里的线程都在做什么。
  sudo -u admin /opt/ifeve/java/bin/jstack 31177 > /home/tengfei.fangtf/dump17
• 第二步：统计所有线程分别处于什么状态，发现300多个线程处于WAITING（onobject-
  monitor）状态。

[tengfei.fangtf@ifeve ~]$ grep java.lang.Thread.State dump17 | awk '{print $2$3$4$5}'
| sort | uniq -c
39 RUNNABLE
21 TIMED_WAITING(onobjectmonitor)
6 TIMED_WAITING(parking)
51 TIMED_WAITING(sleeping)
305 WAITING(onobjectmonitor)
3 WAITING(parking)

• 第三步：打开dump文件查看处于WAITING（onobjectmonitor）的线程在做什么。发现这些线
  程基本全是JBOSS的工作线程，在await。说明JBOSS线程池里线程接收到的任务太少，大量线
  程都闲着。

2 、 死锁

避免死锁的几个常见方法。

• 避免一个线程同时获取多个锁
• ·避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
• ·尝试使用定时锁，使用lock.tryLock（timeout）来替代使用内部锁机制。
• ·对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

3、资源限制的挑战

什么是资源限制？

• 服务器的带宽只有2Mb/s，某个资源的下载速度是1Mb/s每秒，系统启动10个线程下载资
  源，下载速度不会变成10Mb/s
• 在进行并发编程时，要考虑这些资源的限制。硬件资源限
  制有带宽的上传/下载速度、硬盘读写速度和CPU的处理速度。软件资源限制有数据库的连接
  数和socket连接数等。

资源限制引发的问题

• 将代码中串行执行的部分变成并发执行，但是如果将某段串行的代码并发执行，因为受限于资源，仍然在串行执行，这时候程序不仅不
  会加快执行，反而会更慢，因为增加了上下文切换和资源调度的时间。

如何解决资源限制的问题

• 硬件资源限制 ，既然单机的资源有限制，那么就让
  程序在多机上运行。 使用集群。不同的机器处理不同
  的数据。可以通过“数据ID%机器数”，计算得到一个机器编号，然后由对应编号的机器处理这
  笔数据。
• 软件资源限制，可以考虑使用资源池将资源复用。比如使用连接池将数据库和Socket
  连接复用，或者在调用对方webservice接口获取数据时，只建立一个连接。

二 、Java并发机制的底层实现原理

Java代码在编译后会变成Java字节码，字节码被类加载器加载到JVM里，JVM执行字节码，最终需要转化为汇编指令在CPU上执行，Java中所使用的并发机制依赖于JVM的实现和CPU的指令。

volatile的应用

• volatile的定义与实现原理
  • 定义： Java语言规范第3版中对volatile的定义如下：Java编程语言允许线程访问共享变量，为了
    确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。Java语言
    提供了volatile，在某些情况下比锁要更加方便。如果一个字段被声明成volatile，Java线程内存
    模型确保所有线程看到这个变量的值是一致的

• CPU的术语定义

  
  
  mark

volatile是如何来保证可见性的呢? 看下反编译之后的

Java代码如下。
instance = new Singleton(); // instance是volatile变量
转变成汇编代码，如下。
0x01a3de1d: movb $0×0,0×1104800(%esi);0x01a3de24: lock addl $0×0,(%esp);

有volatile变量修饰的共享变量进行写操作的时候会多出第二行汇编代码
，Lock前缀的指令在多核处理器下会引发了两件事情

• 将当前处理器缓存行的数据写回到系统内存。
• 这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效
• JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据
  写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操
  作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一
  致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当
  处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状
  态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存
  里。

volatile的两条实现原则

• Lock前缀指令会引起处理器缓存回写到内存
• 一个处理器的缓存回写到内存会导致其他处理器的缓存无效（例如，在Pentium和P6 family处理器中，如果通过嗅探一个处理
  器来检测其他处理器打算写内存地址，而这个地址当前处于共享状态，那么正在嗅探的处理
  器将使它的缓存行无效，在下次访问相同内存地址时，强制执行缓存行填充。）

synchronized的实现原理与应用

Java中的每一个对象都可以作为锁。具体表现为以下3种形式。

• 对于普通同步方法，锁是当前实例对象。
• 对于静态同步方法，锁是当前类的Class对象。
• 对于同步方法块，锁是Synchonized括号里配置的对象。

代码块同步是使用monitorenter
和monitorexit指令实现的

任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁

mark

mark

锁的升级与对比

在
Java SE 1.6中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状
态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏
向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高
获得锁和释放锁的效率

1.偏向锁

• 大多数情况下，锁不仅不存在多线程竞争，而且总是由同
  一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并
  获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出
  同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否
  存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁
• 如果测试失败，则需
  要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则
  使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

mark

偏向锁在Java 6和Java 7里是默认启用的，但是它在应用程序启动几秒钟之后才激活，如有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0。如果你确定应用程序里所有的锁通常情况下处于竞争状态，可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false，那么程序默认会进入轻量级锁状态。

2.轻量级锁

• 轻量级锁加锁

线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并
将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用
CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失
败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁

• 轻量级锁解锁

轻量级解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成
功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。

mark

因为自旋会消耗CPU，为了避免无用的自旋（比如获得锁的线程被阻塞住了），一旦锁升级成重量级锁，就不会再恢复到轻量级锁状态。当锁处于这个状态下，其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程，被唤醒的线程就会进行新一轮的夺锁之争。

mark

原子操作的实现原理

java 实现 原子操作

• （1）使用循环CAS实现原子操作

JVM中的CAS操作正是利用了处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本
思路就是循环进行CAS操作直到成功为止，以下代码实现了一个基于CAS线程安全的计数器
方法safeCount和一个非线程安全的计数器count。

public class Counter {

    private AtomicInteger atomicI = new AtomicInteger(0);
    private int           i       = 0;

    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> ts = new ArrayList<Thread>(600);
        long start = System.currentTimeMillis();
        for (int j = 0; j < 100; j++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        cas.count();
                        cas.safeCount();
                    }
                }
            });
            ts.add(t);
        }
        for (Thread t : ts) {
            t.start();

        }
        // 等待所有线程执行完成
        for (Thread t : ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println(cas.i);
        System.out.println(cas.atomicI.get());
        System.out.println(System.currentTimeMillis() - start);
    }

    /**
     * 使用CAS实现线程安全计数器
     */
    private void safeCount() {
        for (;;) {
            int i = atomicI.get();
            boolean suc = atomicI.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }

    /**
     * 非线程安全计数器
     */
    private void count() {
        i++;
    }

}

• （2）CAS实现原子操作的三大问题

1）ABA问题。

因为CAS需要在操作值的时候，检查值有没有发生变化，如果没有发生变化
则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它
的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面
追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。从
Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个
类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是
否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

public boolean compareAndSet(
V expectedReference, // 预期引用
V newReference, // 更新后的引用
int expectedStamp, // 预期标志
int newStamp // 更新后的标志
)

2）循环时间长开销大。

自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如
果JVM能支持处理器提供的pause指令，那么效率会有一定的提升。pause指令有两个作用：第
一，它可以延迟流水线执行指令（de-pipeline），使CPU不会消耗过多的执行资源，延迟的时间
取决于具体实现的版本，在一些处理器上延迟时间是零；第二，它可以避免在退出循环的时候
因内存顺序冲突（Memory Order Violation）而引起CPU流水线被清空（CPU Pipeline Flush），从而
提高CPU的执行效率。

3）只能保证一个共享变量的原子操作

当对一个共享变量执行操作时，我们可以使用循
环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子
性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来
操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij。从Java 1.5开始，
JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对
象里来进行CAS操作。

• （3）使用锁机制实现原子操作

锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。JVM内部实现了很多种锁
机制，有偏向锁、轻量级锁和互斥锁。有意思的是除了偏向锁，JVM实现锁的方式都用了循环
CAS，即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时
候使用循环CAS释放锁。