Day791.多线程上下文切换优化方案 -Java 性能调优实战

Posted 2022-12-01 阿昌喜欢吃黄桃

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Day791.多线程上下文切换优化方案 -Java 性能调优实战相关的知识，希望对你有一定的参考价值。

多线程上下文切换优化方案

Hi，我是阿昌，今天学习记录的是关于多线程上下文切换优化方案。

如果是单个线程，在 CPU 调用之后，那么它基本上是不会被调度出去的。

如果可运行的线程数远大于 CPU 数量，那么操作系统最终会将某个正在运行的线程调度出来，从而使其它线程能够使用 CPU ，这就会导致上下文切换。

在多线程中如果使用了竞争锁，当线程由于等待竞争锁而被阻塞时，JVM 通常会将这个线程挂起，并允许它被交换出去。

如果频繁地发生阻塞，CPU 密集型的程序就会发生更多的上下文切换。

那么问题来了，在某些场景下使用多线程是非常必要的，但多线程编程给系统带来了上下文切换，从而增加的性能开销也是实打实存在的。那么该如何优化多线程上下文切换呢？

一、竞争锁优化

大多数在多线程编程中碰到性能问题，第一反应多是想到了锁。

多线程对锁资源的竞争会引起上下文切换，还有锁竞争导致的线程阻塞越多，上下文切换就越频繁，系统的性能开销也就越大。

由此可见，在多线程编程中，锁其实不是性能开销的根源，竞争锁才是。

锁的优化归根结底就是减少竞争。

1、减少锁的持有时间

锁的持有时间越长，就意味着有越多的线程在等待该竞争资源释放。

如果是 Synchronized 同步锁资源，就不仅是带来线程间的上下文切换，还有可能会增加进程间的上下文切换。

例如，可以将一些与锁无关的代码移出同步代码块，尤其是那些开销较大的操作以及可能被阻塞的操作。

优化前

public synchronized void mySyncMethod()  
        businesscode1();  
        mutextMethod();  
        businesscode2();

优化后

public void mySyncMethod()  
        businesscode1();  
        synchronized(this)
        
            mutextMethod();  
        
        businesscode2();

2、降低锁的粒度

同步锁可以保证对象的原子性，可以考虑将锁粒度拆分得更小一些，以此避免所有线程对一个锁资源的竞争过于激烈。

具体方式有以下两种：

锁分离
与传统锁不同的是，读写锁实现了锁分离，也就是说读写锁是由“读锁”和“写锁”两个锁实现的，其规则是可以共享读，但只有一个写。这样做的好处是，在多线程读的时候，读读是不互斥的，读写是互斥的，写写是互斥的。而传统的独占锁在没有区分读写锁的时候，读写操作一般是：读读互斥、读写互斥、写写互斥。所以在读远大于写的多线程场景中，锁分离避免了在高并发读情况下的资源竞争，从而避免了上下文切换。
锁分段
在使用锁来保证集合或者大对象原子性时，可以考虑将锁对象进一步分解。例如，我之前讲过的 Java1.8 之前版本的 ConcurrentHashMap 就使用了锁分段。

3、非阻塞乐观锁替代竞争锁

volatile 关键字的作用是保障可见性及有序性，volatile 的读写操作不会导致上下文切换，因此开销比较小。但是，volatile 不能保证操作变量的原子性，因为没有锁的排他性。

CAS 是一个原子的 if-then-act 操作，CAS 是一个无锁算法实现，保障了对一个共享变量读写操作的一致性。CAS 操作中有 3 个操作数，内存值 V、旧的预期值 A 和要修改的新值 B，当且仅当 A 和 V 相同时，将 V 修改为 B，否则什么都不做，CAS 算法将不会导致上下文切换。

Java 的 Atomic 包就使用了 CAS 算法来更新数据，就不需要额外加锁。上面我们了解了如何从编码层面去优化竞争锁，那么除此之外，JVM 内部其实也对 Synchronized 同步锁做了优化，在 JDK1.6 中，JVM 将 Synchronized 同步锁分为了偏向锁、轻量级锁、自旋锁以及重量级锁，优化路径也是按照以上顺序进行。

JIT 编译器在动态编译同步块的时候，也会通过锁消除、锁粗化的方式来优化该同步锁。

二、wait/notify 优化

在 Java 中，可以通过配合调用 Object 对象的 wait() 方法和 notify() 方法或 notifyAll() 方法来实现线程间的通信。

在线程中调用 wait() 方法，将阻塞等待其它线程的通知（其它线程调用 notify() 方法或 notifyAll() 方法），在线程中调用 notify() 方法或 notifyAll() 方法，将通知其它线程从 wait() 方法处返回。

下面通过 wait() / notify() 来实现一个简单的生产者和消费者的案例，代码如下：

public class WaitNotifyTest 
    public static void main(String[] args) 
        Vector<Integer> pool=new Vector<Integer>();
        Producer producer=new Producer(pool, 10);
        Consumer consumer=new Consumer(pool);
        new Thread(producer).start();
        new Thread(consumer).start();
    

  /**
   * 生产者
   * @author admin
   *
   */
  class Producer implements Runnable
      private Vector<Integer> pool;
      private Integer size;
      
      public Producer(Vector<Integer>  pool, Integer size) 
          this.pool = pool;
          this.size = size;
      
      
      public void run() 
          for(;;)
              try 
                  System.out.println("生产一个商品 ");
                  produce(1);
               catch (InterruptedException e) 
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              
          
      
      private void produce(int i) throws InterruptedException
          while(pool.size()==size)
              synchronized (pool) 
                  System.out.println("生产者等待消费者消费商品,当前商品数量为"+pool.size());
                  pool.wait();//等待消费者消费
              
          
          synchronized (pool) 
              pool.add(i);
              pool.notifyAll();//生产成功，通知消费者消费
          
      
  


  /**
   * 消费者
   * @author admin
   *
   */
  class Consumer implements Runnable
      private Vector<Integer>  pool;
      public Consumer(Vector<Integer>  pool) 
          this.pool = pool;
      
      
      public void run() 
          for(;;)
              try 
                  System.out.println("消费一个商品");
                  consume();
               catch (InterruptedException e) 
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              
          
      
      
      private void consume() throws InterruptedException
          synchronized (pool) 
              while(pool.isEmpty()) 
                  System.out.println("消费者等待生产者生产商品,当前商品数量为"+pool.size());
                  pool.wait();//等待生产者生产商品
              
          
          synchronized (pool) 
              pool.remove(0);
              pool.notifyAll();//通知生产者生产商品

1、wait/notify 的使用导致了较多的上下文切换

结合以下图片，可以看到，在消费者第一次申请到锁之前，发现没有商品消费，此时会执行 Object.wait() 方法，这里会导致线程挂起，进入阻塞状态，这里为一次上下文切换。

当生产者获取到锁并执行 notifyAll() 之后，会唤醒处于阻塞状态的消费者线程，此时这里又发生了一次上下文切换。

被唤醒的等待线程在继续运行时，需要再次申请相应对象的内部锁，此时等待线程可能需要和其它新来的活跃线程争用内部锁，这也可能会导致上下文切换。

如果有多个消费者线程同时被阻塞，用 notifyAll() 方法，将会唤醒所有阻塞的线程。而某些商品依然没有库存，过早地唤醒这些没有库存的商品的消费线程，可能会导致线程再次进入阻塞状态，从而引起不必要的上下文切换。

2、优化 wait/notify 的使用，减少上下文切换

首先，在多个不同消费场景中，可以使用 Object.notify() 替代 Object.notifyAll()。因为 Object.notify() 只会唤醒指定线程，不会过早地唤醒其它未满足需求的阻塞线程，所以可以减少相应的上下文切换。

其次，在生产者执行完 Object.notify() / notifyAll() 唤醒其它线程之后，应该尽快地释放内部锁，以避免其它线程在唤醒之后长时间地持有锁处理业务操作，这样可以避免被唤醒的线程再次申请相应内部锁的时候等待锁的释放。

最后，为了避免长时间等待，我们常会使用 Object.wait (long）设置等待超时时间，但线程无法区分其返回是由于等待超时还是被通知线程唤醒，从而导致线程再次尝试获取锁操作，增加了上下文切换。

这里建议使用 Lock 锁结合 Condition 接口替代 Synchronized 内部锁中的 wait / notify，实现等待／通知。

这样做不仅可以解决上述的 Object.wait(long) 无法区分的问题，还可以解决线程被过早唤醒的问题。Condition 接口定义的 await 方法、signal 方法和 signalAll 方法分别相当于 Object.wait()、 Object.notify() 和 Object.notifyAll()。