JAVA并发编程的艺术--并发编程的挑战

点关注，不迷路！如果本文对你有帮助的话不要忘记点赞支持哦！

1.1上下文切换

​ 多线程的支持：CPU通过给每个线程分配CPU时间片来实现这个机制。

​ 上下文切换：CPU通过分配时间片算法循环执行任务时，任务切换前会保存前一个任务的状态，以便切回任务，任务从保存到再次加载的过程就是一次上下文切换。上下文切换会影响多线程的执行速度。

1.1.1多线程一定快吗？

• 代码见part01中ConcurrencyTest类。

  package io.ilss.concurrency.part01;
  
  /**
   * className ConcurrencyTest
   * description ConcurrencyTest
   *
   * @author feng
   * @version 1.0
   * @date 2019-01-21 12:47
   */
  public class ConcurrencyTest {
      private static final long count = 100001L;
  
      public static void main(String[] args) throws InterruptedException {
          concurrency();
          serial();
      }
  
      private static void concurrency() throws InterruptedException {
          long start = System.currentTimeMillis();
          Thread thread = new Thread(new Runnable() {
              public void run() {
                  long a = 0;
                  for (long i = 0; i < count; i++) {
                      a += 5L;
                  }
              }
          });
          thread.start();
          long b = 0;
          for (long i = 0; i < count; i++) {
              b--;
          }
          thread.join();
          long time = System.currentTimeMillis() - start;
          System.out.println("Concurrency : " + time + "ms, b = " + b);
      }
  
      private static void serial() {
          long start = System.currentTimeMillis();
          long a = 0;
          for (long i = 0; i < count; i++) {
              a += 5;
          }
          long b = 0;
          for (long i = 0; i < count; i++) {
              b--;
          }
          long time = System.currentTimeMillis() - start;
          System.out.println("serial : " + time + "ms, b = " + b + ", a = " + a);
      }
  }
  

通过更改count从1万到1亿可看成，执行count越低，串行执行效率更高。这是因为线程有创建和上下文切换的开销。但是到了一定的数量过后，多线程的优势就会体现出来。

1.1.2

• 可以用Lmbench3测量上下文切换的时间 （Lmbench3是一个性能分析工具）

1.1.3 如何减少上下文切换

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

• 无锁并发编程：即用一些方法来避免使用锁。
• CAS算法：Atomic包使用CAS算法更新数据
• 只用最少线程：避免创建不需要的线程
• 协程：在单线程中实现多任务调度，并在单线程中维持多个任务间的切换

1.1.4 减少上下文切换实战

减少WAITING线程，系统上下文切换的次数就会少。线程从WAITING到RUNNABLE都会进行一次上下文切换。

1.2 死锁

代码见part01中的DeadLockDemo类

 

package io.ilss.concurrency.part01;

/**
 * className DeadLockDemo
 * description DeadLockDemo
 *
 * @author feng
 * @version 1.0
 * @date 2019-01-21 16:28
 */
public class DeadLockDemo {
    private static String A = "A";
    private static String B = "B";

    public static void main(String[] args) {
        new DeadLockDemo().deadLock();
    }

    private void deadLock() {

        Thread t1 = new Thread(() -> {
            synchronized (A) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (B) {
                    System.out.println("1");
                }
            }
        });
        Thread t2 = new Thread(() ->{
            synchronized (B) {
                synchronized (A) {
                    System.out.println("2");
                }
            }
        });
        t1.start();
        t2.start();

    }
}

• t1（Thread-0）拿到A锁过后sleep2s，t2（"Thread-1）同时进入B锁代码块，由于t1还在执行A锁的代码块阻塞进程，等t1线程2s时间到了想进入B的代码块时，由于t2还在执行B锁的代码块，就行形成了拿了A的t1要B，拿了B的t2要A，形成死锁。如下信息所示

 

Java stack information for the threads listed above:
===================================================
"Thread-1":
    at io.ilss.concurrency.part01.DeadLockDemo.lambda$deadLock$1(DeadLockDemo.java:36)
    - waiting to lock <0x000000076ac26378> (a java.lang.String)
    - locked <0x000000076ac263a8> (a java.lang.String)
    at io.ilss.concurrency.part01.DeadLockDemo$$Lambda$2/2129789493.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)
"Thread-0":
    at io.ilss.concurrency.part01.DeadLockDemo.lambda$deadLock$0(DeadLockDemo.java:29)
    - waiting to lock <0x000000076ac263a8> (a java.lang.String)
    - locked <0x000000076ac26378> (a java.lang.String)
    at io.ilss.concurrency.part01.DeadLockDemo$$Lambda$1/1607521710.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

注：先使用jps找到运行所在的pid，然后用jstack 查看如上信息

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

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

1.3 资源限制的挑战

• 并发编程时需要考虑：硬件资源如带宽的上传/下载速度、硬盘的读写速度和CPU的处理速度。软件资源如数据库连接数、socket连接数等
• 资源限制引发的问题：多线程程序由于资源限制，仍然串行执行，会因为上下文切换和资源调度而降低效率
• 解决资源限制的问题：硬件上可以使用集群，不同的机器处理不同的数据；软件上可以考虑使用资源池将资源复用，如：数据库连接池、socket连接复用、调用webservice接口获取数据时，只建立一个连接。
• 在资源限制情况下进行并发线程：根据不同的资源限制调整程序的并发度。

上述面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2020收集的一些大厂的面试真题（都整理成文档，小部分截图），有需要的可以 点击进入暗号：csdn 。

2.1 volatile的应用

• volatile 在多处理器开发中保证共享变量的“可见性”，当多个线程同时访问共享变量的时候，volatile修饰的变量的被某个线程改变可以被其他线程感知。

1. volatile的定义于实现原理

   如果一个字段被声明成volatile，Java线程内存模型确保所有线程看到这个变量的值是一致的。

   • CPU术语

   术语	描述
   内存屏障（memory barriers）	是一组处理器指令，用于实现对内存操作的顺序限制
   缓冲行（cache line）	缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线，需要使用多个主内存读周期
   原子操作（atomic operations）	不可中断的一个或一系列的操作；
   缓存行填充（cache line fill）	当处理器识别到从内存中读取操作数是可缓存的，处理器读取整个缓存行到适当的缓存；
   缓存命中（cache hit）	如果进行高速缓存行填充操作的内存位置任然是下次处理器访问的地址时，处理器从缓存中读取操作数，而不是从内存中读取；
   写命中（write hit）	当处理器操作数写回到一个内存缓存的区域时，它首先会检查这个缓存的内存地址是否在缓存行中，如果存在一个有效的缓存行，则处理器将这个操作数写回到缓存，而不是写回到内存，这个操作被称为写命中；
   写缺失（write miss the cache）	一个有效的缓存行被写入到不存在的内存区域。

   volatile SomeVar instanse = new Singleton();
   

   转换成X86汇编代码

   movb $0*), 0*1104800;
   lock addl $0*0,(%esp);
   

   有volatile修饰的共享变量进行写操作会有第二行lock指令。

   • lock指令：

     1）将当前处理器缓存行数据写回到内存

     2）这个写会让在其他CPU里缓存了该地址的数据无效

   在多处理器下，为了保证各个处理器的缓存是一致的，会实现缓存一致性协议。每个处理器通过探知总线上传输的数据来检测自己的缓存是否过期，如果发现自己的缓存行对应的内存地址被修改，则会将当前处理器的缓存设为无效，当要对这个数据进行修改操作的时候，会重新再系统内存中读入CPU缓存。

   • volatile实现的两条原则：

     1）Lock前缀指令会引起处理器缓存回写到内存。

     2）一个处理器的缓存回写到内存会导致其他处理器的缓存无效。

   1. volatile的使用优化：
      • 讲共享变量追到处理器位数，32位->32字节，32/4=8；64位->64字节，64/8=16
      • 书上给了一个LinkedTransferQueue的类，Java8已经不是书上的样子了。
      • Java7过后变得更加智慧了。淘汰或者重新排列了无用字段。

2.2 synchronized 的实现原理与应用

Java中每个对象都可以作为锁，有以下三种形式：

• 对于普通同步方法，锁的是当前实例对象。
• 对于静态同步方法，锁的是当前类的Class对象（Object.class）
• 对于同步代码块，锁的是括号内的对象。可以是普通的object，也可以是object.class

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步

代码块同步是使用monitorenter和monitorexit指令实现的，同步方法是另外的一种方式实现的。

monitorenter和monitorexit指令在编译后插入到同步代码块的开始、结束处或异常处，JVM要保证每个enter都有exit与之匹配。

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

2.2.1 Java对象头

synchronized用的锁是存在Java对象头里面的。

对象是数组：3个字宽存储对象头

对象非数组：2个字宽存储对象头

注：32位1字宽等于4字节，即32bit

2.2.2 锁的升级与对比

Java SE 6 中锁一共有4种状态，级别从低到高：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。这几个状态会随着竞争情况逐渐升级。

锁可以升级但是不能降级。

1. 偏向锁：

   线程访问同步快并获得锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程id

   进入和退出同步块：

   ​ 1）检测对象头的Mark Word是否存了当前线程的偏向锁。存了表示已经获得锁

   ​ 2）没有继续测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）设置了就尝试使用CAS将对象头的偏向锁指向当前线程

   ​ 3）如果没有设置，就使用CAS竞争锁

   偏向锁的撤销：

   ​ 当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。

   ​ 锁的撤销需要等待全局安全点（在这个时间上没有正在执行的字节码）

   ​ 先暂停拥有偏向锁的线程，然后检查该线程是否活着，不处于活动状态，则将对象头设置成无锁状态，如果活着，拥有偏向锁的栈就会被执行，遍历对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向其他线程，要么回复到无锁或者标记对象不合适偏向锁，最后唤醒暂停的线程。

   关闭偏向锁：

   ​ Java6 以后偏向锁是默认启用的。但是要在程序启动几秒后才激活。

   ​ 可以通过JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0

   ​ 可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false 程序会默认进入轻量级锁状态。

2. 轻量级锁：

   轻量级锁加锁：

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

   轻量级锁解锁：

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

2.3 原子操作的实现原理

2.处理器如何实现原子操作：

​ 处理器实现原子操作：现在的处理器都能懂保证单处理对同一个缓存行里进行的16/32/64位的操作是原子的。

​ 对于复杂的内存操作，处理器不保证，但是提供了两个机制来保证复杂内存操作的原子性：总线锁定和缓存锁定。

​ 1）总线锁定就是使用了处理器提供的LOCK#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞，此时该处理器就可以独占内存。

​ 2）缓存锁定是指内存区域如果被缓存在处理器缓存中，在Lock操作期间被锁定，那么它之心锁操作回写到内存时会修改内部的内存地址，并允许他的缓存一致性机制来保证操作的原子性。 缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

​ 处理器两种不会使用缓存锁定的情况：

• 操作的数据不能被缓存在处理器内部，或者操作的数据跨多个缓存行，则会调用总线锁定
• 有些处理器不支持缓存锁定。

1. Java中如何实现原子操作：

   Java实现原子操作的两种方式 锁 和 循环CAS

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

   package io.ilss.concurrency.part02;
   
   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.atomic.AtomicInteger;
   
   /**
    * className Counter
    * description Counter
    *
    * @author feng
    * @version 1.0
    * @date 2019-01-21 22:21
    */
   public class Counter {
       private AtomicInteger atomicInt = new AtomicInteger(0);
       private int i = 0;
   
       public static void main(String[] args) throws InterruptedException {
           final Counter cas = new Counter();
           List ts = new ArrayList<>(600);
           long start = System.currentTimeMillis();
           for (int j = 0 ; j< 100; j++) {
               Thread t = new Thread(() -> {
                   for (int i = 0; i < 10000; i++) {
                       cas.count();
                       cas.safeCount();
                   }
               });
               ts.add(t);
           }
           for (Thread t : ts) {
               t.start();
           }
           for (Thread t : ts) {
               t.join();
           }
           System.out.println(cas.i);
           System.out.println(cas.atomicInt);
           System.out.println(System.currentTimeMillis() - start);
       }
       private void safeCount() {
           while (true) {
               int i = atomicInt.get();
               boolean suc = atomicInt.compareAndSet(i, ++i);
               if (suc) {
                   break;
               }
           }
       }
   
       private void count() {
           i++;
       }
   }
   

   995994
   1000000
   193
   
   Process finished with exit code 0
   

   CAS实现原子操作的三大问题：

   1. ABA问题，简而言之则是检查时没发生变化，但是实际上变化了。ABA解决的思路就是使用版本号：1A->2B->3C...，Java1.5之后官方提供了一个AtomicStampedReference来结局ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并检查当前标志是否等于预期标志，如果全部相等，则执行原子操作进行更新。
   2. 循环时间开销大，
   3. 只能保证一个共享变量的原子操作，循环CAS的方式只适用于一个共享变量，如果多个共享变量则需要用锁，不过java1.5之后提供了一个AtomicReference类来保证引用对象之间的原子性，可以吧多个变量放在一个对象里来进行操作CAS操作。
   4. 使用锁机制来实现原子操作， 锁机制保证了只有获得锁的线程才能操作锁定的内存区域。JVM中偏向锁、轻量级锁和互斥锁都实现了。另外除了偏向锁，其他所都实现了CAS。

 

到此这篇关于文章就结束了！

 

点关注，不迷路！如果本文对你有帮助的话不要忘记点赞支持哦！

 

希望对大家有所帮助，有用的话点赞给我支持！