并发编程的优缺点

你的名字 2020-06-14 10:06 782阅读 0赞

## 并发编程的优缺点 ##

Java并发编程是整个Java开发体系中最难以理解，但也是最重要的知识点之一，因此学习起来比较费劲，从而导致很多人望而却步，但是无论是职场面试还是高并发高流量的系统的实现都离不开并发编程，能够真正掌握并发编程的人才在市场上供不应求。

### 为什么要使用并发编程（优点） ###

#### 充分利用多核CPU的计算能力 ####

**摩尔定律**：当价格不变时，集成电路上可容纳的元器件的数目，约每隔18-24个月便会增加一倍，性能也将提升一倍。换言之，每一美元所能买到的电脑性能，将每隔18-24个月翻一倍以上。这一定律揭示了信息技术进步的速度。

一直以来，硬件的发展极其迅速，也有一个很著名的"摩尔定律"，你可能会奇怪明明讨论的是并发编程为什么会扯到了硬件的发展，这其中的关系应该是多核CPU的发展为并发编程提供的硬件基础。摩尔定律并不是一种自然法则或者是物理定律，它只是基于观测数据，对未来的一种预测。按照所预测的速度，我们的计算能力会按照指数级别的速度增长，不久以后会拥有超强的计算能力，正是在畅想未来的时候，2004年，Intel宣布4GHz芯片的计划推迟到2005年，然后在2004年秋季，Intel宣布彻底取消4GHz的计划，也就是说摩尔定律的有效性超过了半个世纪戛然而止。但是，聪明的硬件工程师并没有停止研发的脚步，他们为了进一步提升计算速度，不是再追求单独的计算单元，而是将多个计算单元整合到了一起，也就是形成了多核CPU。短短十几年的时间，家用型CPU，比如Intel i7就可以达到4核心甚至8核心。而专业服务器则通常可以达到几个独立的CPU，每一个CPU甚至拥有多达8个以上的内核。因此，摩尔定律似乎在CPU核心扩展上继续得到体验。因此，多核的CPU的背景下，催生了并发编程的趋势，**通过并发编程的形式可以将多核CPU的计算能力发挥到极致，性能得到提升**。

顶级计算机科学家Donald Ervin Knuth如此评价这种情况：在我看来，这种现象（并发）或多或少是由于硬件设计者无计可施导致的，他们将摩尔定律的责任推给了软件开发者。

#### 方便进行业务拆分，提升系统并发能力和性能 ####

在特殊的业务场景下先天的就适合于并发编程。**现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能**。比如在图像处理领域，一张1024X768像素的图片，包含78万6千多个像素。将所有的像素遍历一边都需要很长的时间，面对如此复杂的计算量就需要充分利用多核CPU的计算能力。又比如当我们在网上购物时，为了提升响应速度，减库存、生成订单等等这些操作就可以进行拆分，利用多线程的技术完成。**面对复杂业务模型，并行程序会比串行程序更适应业务需求，而并发编程更能吻合这种业务拆分** 。

### 并发编程的缺点 ###

并发编程的目的就是为了能提高程序的执行效率，提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如：**内存泄漏、上下文切换、线程安全、死锁**等问题。

#### 频繁的上下文切换 ####

任务从保存到再加载就是一次上下文切换。

时间片是CPU分配给各个线程的时间，因为时间非常短，所以CPU不断通过切换线程，让我们觉得多个线程是同时执行的，时间片一般是几十毫秒。而每次切换时，需要保存当前的状态，以便能够进行恢复先前的状态，而这个切换时非常损耗性能，过于频繁反而无法发挥出多线程编程的优势。

**减少上下文切换的解决方案**

*  **无锁并发编程**：可以参照concurrentHashMap锁分段的思想，不同的线程处理不同段的数据，这样在多线程竞争的条件下，可以减少上下文切换的时间。
 *  **CAS算法**：利用Atomic下使用CAS算法来更新数据，使用了乐观锁，可以有效的减少一部分不必要的锁竞争带来的上下文切换。
 *  **使用最少线程**：避免创建不需要的线程，比如任务很少，但是创建了很多的线程，这样会造成大量的线程都处于等待状态。
 *  **协程**：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。

由于上下文切换也是个相对比较耗时的操作，所以在"java并发编程的艺术"一书中有过一个实验，并发累加未必会比串行累加速度要快。 可以使用**Lmbench3测量上下文切换的时长** **vmstat测量上下文切换次数**

#### 线程安全 ####

多线程编程中最难以把握的就是临界区线程安全问题，稍微不注意就会出现死锁的情况，一旦产生死锁就会造成系统功能不可用。

public class DeadLockDemo {
        private static String resource_a = "A";
        private static String resource_b = "B";
    
        public static void main(String[] args) {
            deadLock();
        }
    
        public static void deadLock() {
            Thread threadA = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (resource_a) {
                        System.out.println("get resource a");
                        try {
                            Thread.sleep(3000);
                            synchronized (resource_b) {
                                System.out.println("get resource b");
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            Thread threadB = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (resource_b) {
                        System.out.println("get resource b");
                        synchronized (resource_a) {
                            System.out.println("get resource a");
                        }
                    }
                }
            });
            threadA.start();
            threadB.start();
    
        }
    }

在上面的这个demo中，开启了两个线程threadA， threadB，其中threadA占用了resource\_a， 并等待被threadB占用的resource \_b。threadB占用了resource \_b正在等待被threadA占用的resource \_a。因此threadA，threadB出现线程安全的问题，形成死锁。同样可以通过jps，jstack证明这种推论：

"Thread-1":
      waiting to lock monitor 0x000000000b695360 (object 0x00000007d5ff53a8, a java.lang.String),
      which is held by "Thread-0"
    "Thread-0":
      waiting to lock monitor 0x000000000b697c10 (object 0x00000007d5ff53d8, a java.lang.String),
      which is held by "Thread-1"
    
    Java stack information for the threads listed above:
    ===================================================
    "Thread-1":
            at learn.DeadLockDemo$2.run(DeadLockDemo.java:34)
            - waiting to lock <0x00000007d5ff53a8(a java.lang.String)
            - locked <0x00000007d5ff53d8(a java.lang.String)
            at java.lang.Thread.run(Thread.java:722)
    "Thread-0":
            at learn.DeadLockDemo$1.run(DeadLockDemo.java:20)
            - waiting to lock <0x00000007d5ff53d8(a java.lang.String)
            - locked <0x00000007d5ff53a8(a java.lang.String)
            at java.lang.Thread.run(Thread.java:722)
    
    Found 1 deadlock.

如上所述，完全可以看出当前死锁的情况。

那么，通常可以用如下方式**避免死锁**的情况：

1.  避免一个线程同时获得多个锁；
2.  避免一个线程在锁内部占有多个资源，尽量保证每个锁只占用一个资源；
3.  尝试使用定时锁，使用lock.tryLock(timeOut)，当超时等待时当前线程不会阻塞；
4.  对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

所以，如何正确的使用多线程编程技术有很大的学问，比如如何保证线程安全，如何正确理解由于JVM内存模型在原子性，有序性，可见性带来的问题，比如数据脏读，DCL等问题。而在学习多线程编程技术的过程中也会让你收获颇丰。

## 易混淆的概念 ##

### 阻塞与非阻塞 ###

阻塞与非阻塞的重点在于进/线程等待消息时候的行为，也就是在等待消息的时候，当前进/线程是挂起状态，还是非挂起状态。

`阻塞`：调用在发出去后，在消息返回之前，当前进/线程会被挂起，直到有消息返回，当前进/线程才会被激活；

`非阻塞`：调用在发出去后，不会阻塞当前进/线程，而会立即返回。

### 同步与异步 ###

`同步`：当一个同步调用发出去后，调用者要一直等待调用结果的返回后，才能进行后续的操作。

`异步`：当一个异步调用发出去后，调用者不用管被调用方法是否完成，都会继续执行后面的代码。 异步调用，要想获得结果，一般有两种方式：

*  主动轮询异步调用的结果；
 *  被调用方通过callback来通知调用方调用结果；

比如，在超市购物，如果一件物品没了，你得等仓库人员跟你调货，直到仓库人员跟你把货物送过来，你才能继续去收银台付款，这就类似同步调用。而异步调用了，就像网购，你在网上付款下单后，什么事就不用管了，该干嘛就干嘛去了，当货物到达后你收到通知去取就好。

### 临界区 ###

临界区用来表示一种公共资源或者说是共享数据，可以被多个线程使用。但是每个线程使用时，一旦临界区资源被一个线程占有，那么其他线程必须等待。

### 并发与并行 ###

*  **并发**： 同一时间段，多个任务交替执行 (单位时间内不一定同时执行)；
 *  **并行**：单位时间内，多个任务同时执行。真正意义上的“同时进行”，真正的并行只能出现在拥有多个CPU的系统中；
 *  **串行**：线程串行的情况下，有n个任务或者你可以理解n个方法，由一个线程顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

### 上下文切换 ###

多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。

概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。

上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。