并发的基础概念以及优缺点

一. 为什么要有并发

首先我们应该了解什么是并发,很多时候我们在工作的过程当中,习惯会以单线程的思维来进行项目开发,因为这种方式是最易于理解的,也是最不容易出错的。

当然,这种编程方式在项目简单,并且用户访问量并不大的情况下可以发挥较好的作用,但是只要项目迭代到某个高级阶段,或者说因为比较好的推广,项目得到了比较多用户的使用,这种时候,项目中单线程的处理方式一定会出现处理效率上的瓶颈,常见的问题就是响应速度变慢,也就是处理速度会变慢,那这个时候如果将原来单线程的任务改成多线程的方式处理,则可以大大地提升处理效率。

二. 并发与并行的区别

在这边,我们首先要理清并发与并行两者的区别。我们讲的并发其实主要是一段时间内,多个事件同时对一个任务进行处理,而并行则是同一个时间点,会有多个事件同时处理。

举个通俗点的例子:现在有一个客人订了3杯咖啡并且店里面有3个人,那完成这些咖啡有两个思路,第一个是,三个人每个人轮流沏一杯咖啡,直到一杯咖啡沏完,再接下去三个人同时轮流沏另一杯咖啡。第二个思路则是,三个人每人都自己沏自己的咖啡。
并发与并行的区别
从图中其实可以看到,并发其实就是多个线程争抢一个任务,而并行则不会抢占资源,每一个任务都是由自己的线程单独处理的。

三. 并发编程的优点

并发编程也就是多线程编程,在实际使用中有许多的优点,毕竟如果没有优点也不会使用了。

1. 充分地利用多核 CPU 的好处

现代处理器上核心数量越来越多的情况下,计算机的并行计算能力被大大地加强了。而单线程只使用了一个处理器核心,其它的核心一直在空闲这,那多核的能力就无法得到充分地利用,处理器的使用率就远远达不到想象中的状态。

2. 提高系统的响应速度

并发编程在任务处理上的效率远远大于单线程,就像一个人可以分成许多个克隆人一起完成一个任务,人增加了,速度自然就提升上来了。

比如在下载文件的时候,在单线程的情况下,只能一行一行的进行文件内容数据的拼接与处理,而如果使用多线程,那系统就可以将一个文件中多行数据分配给不同的线程处理,最后再进行内容整合并展示给用户,大大的提高了单个任务的处理效率。如果将这种多线程的思想用到其它业务流程上,那系统的整体性能就会有一个飞跃性的提升。这也就是为什么复杂系统上,使用多线程处理任务一定会有着极大的使用率。

四. 并发编程的缺点

虽然在上面说道多线程会加快任务的处理,但是多线程一定会很快吗,也就是说多线程是否在某些情况下会比单线程的效率低?

答案是多线程并不一定会比单线程快。其中有两个有可能导致并发处理任务速度减慢或者失败的原因是:上下文切换和死锁。

1. 上下文切换

什么是上下文切换?CPU 通过时间片分配算法来循环执行任务,通过给每个线程分配 CPU 时间片来支持多线程的运行。时间片是 CPU 分配给每个线程的时间,一般时间片是几十毫秒,通过给每个线程分配时间片,并且在很短的时间内从一个任务切换到下一个任务,在切换之前会保存一次任务状态,并且下一次切换回这个任务时又加载状态并执行了这个任务,这一次过程就是上下文切换。

从定义中就可以猜想,是否是因为线程切换的原因导致了某些情况多线程比单线程处理任务的速度还要慢?在下面的代码中分别对单线程和多线程进行效率上的对比。

public class ThreadTest {  
  
    private static final long maxCount = 1000L;  
  
    /**  
     * 并发  
     */  
    public static long concurrency() {  
        long start = System.nanoTime();  
  
        // 新开一个线程执行任务  
        Thread thread = new Thread(() -> {  
            for (long i = 0; i < maxCount; i++) {  
                int x = 0;  
                x += 1;  
            }  
        });  
        thread.start();  
  
        // 原线程处理其他任务  
        int y = 0;  
        for (long i = 0; i < maxCount; i++) {  
            y += 1;  
        }  
  
        try {  
            // 等待新开启的线程结束任务  
            thread.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
  
        return System.nanoTime() - start;  
    }  
  
    /**  
     * 串行  
     */  
    public static long serial() {  
        long start = System.nanoTime();  
        int x = 0;  
        for (int i = 0; i < maxCount; i++) {  
            x += 1;  
        }  
  
        int y = 0;  
        for (long i = 0; i < maxCount; i++) {  
            y += 1;  
        }  
  
        return System.nanoTime() - start;  
    }  
  
    public static void main(String[] args) {  
        long concurrencyTime = concurrency();  
        long serialTime = serial();  
        System.out.println("concurrency:" + concurrencyTime + "ns");  
        System.out.println("serial:" + serialTime + "ns");  
        System.out.println("比例: " + (double) concurrencyTime / serialTime);  
    }  
}

由上面代码试验可以得出下边的表格:

循环次数串行消耗 ns并发消耗 ns并发 / 串行
一千17000268662001580
一万15460027523600178
十万7280002808230038
一百万19782002773540014
一千万7670800306559003
一亿60337400568028000.94
十亿5604016003172157000.566

可以从表格中看到,在循环次数不大的情况下,比如在循环一百万次之前,其实并发并没有很大的优势,相反还可能出现比串行还要慢。在循环次数一亿以上,并发的优势才能体现出来。当然展示的例子当中的任务比较简单,所以实际情况还要自己去验证。

所以从上面的例子中看到,并发中上下文的切换有时候消耗的资源远比想象中的要高,所以尽量在需要的情况下再去对任务进行并发优化。

既然上下文切换也会消耗资源,降低效率,那如何来减少上下文切换?有四种方法:使用无锁并发编程、CAS算法、协程以及减少线程。

  • 无锁并发编程:一份数据分成多段,并且使用不同的线程处理分别处理这些数据。
  • CAS 算法:Unsafe 类中有相关的 CAS 方法,可以不使用锁,java.util.concurrent.atomic包下有使用 CAS 的各种原子操作类。
  • 协程:协程是一种比线程更加轻量级的存在,一个线程可以有多个协程。
  • 减少线程:线程并不是越多越好,而是有一个合适的范围,需要根据硬件资源来决定,通常线程数量是 CPU 核心数量 + 1。

2. 死锁

在之后会讲到为了解决原子性问题会涉及到锁的使用,但是锁的使用也是会出现 BUG,比如著名的死锁问题。我们常说的 synchronized 和 Lock 都是加锁思想的不同体现,两者各有侧重点,虽然两者实现方式不一样,但其实都是解决同一个问题。

那什么是死锁?死锁从字面解释上来讲比较难以理解,那这时候可以借鉴现实的场景来理解死锁的概念。我们想象两个人想要泡咖啡,结果一个人拿水壶,一个人拿杯子,两个人僵持着谁也不先放弃,那这时候泡咖啡任务就不能完成,而且水壶和杯子被两个人持有但又不放开,这种就是死锁问题。

用伪代码表示出来就是:两个人就是两个线程,每个线程都持有了一个锁,然后互不想让,最终导致泡咖啡这件任务永远无法完成。

private Object 咖啡;  
  
void 泡咖啡() {  
    synchronized (杯子) {  
        synchronized (水壶) {  
            泡咖啡;  
        }  
    }  
}

五. 并发编程还会出现什么问题

在了解了并发的优缺点以后,并不是一劳永逸了,如果不能正确理解并发编程的底层原理,还是会出现很多 BUG。

并发编程出现 BUG 的源头

我们常遇到 BUG 的源头主要有三个:原子性、有序性、可见性。为了解决这三种情况,Java 自带了 synchronizedvolatilefinal关键词和 Happens-Before 的六项规则来解决这三个问题。

1. 可见性问题

多个线程共同修改一个共享变量时,一个线程修改的变量结果能马上被其他线程获取到。
导致原因:缓存

很多人都知道,我们目前的计算机体系里面,CPU、内存和硬盘之间一直有着明显的速度差异,就比如 CPU 的执行速度远远大于内存,那这时候为了缓解这中间的速度差异,CPU 中又增加了缓存。并且 CPU 中不同的线程的共享变量其实都是放在同一个缓存当中,每个线程如果想对共享变量进行操作,都要去同一个缓存中获取并修改。
单核CPU
在单核时代,不同的线程反正都源于一个 CPU,那这时候问题不大。但是,在多核 CPU 的时代下,每个 CPU 都有着自己的缓存,每个缓存又到同一个内存中去获取共享变量的值(当然我们这边暂时不考虑缓存有几级),那这时候每个缓存都保存了不同的值,如果一个 CPU 中的线程修改了自己的缓存,这时候其它 CPU 的线程无法获取到那个 CPU 中的变量的值,这时候就会出现可见性问题,也就是说一个 CPU 中的线程无法观察到另一个 CPU 中的操作。
多核 CPU

2. 原子性问题

原子性比较好理解,就是一个操作或多个操作只能全部完成或者全部失败,而不能出现完成一半的情况。
导致原因:线程切换

在上面讲到上下文切换的时候提到 CPU 是通过给每个线程分配时间片来实现多线程的运行,那这时候就涉及到线程的切换,然而就是因为线程的切换,所以才导致了原子性问题的出现。

我们在平常编写的代码虽然看起来有时候是一条语句,但其实在 CPU 层面是分为多条指令执行的,比如 i += 1;,虽然我们的第一反应直接是 i 加上 1,但实际是三条指令:1. 获取内存中 i 变量的值,2. i 加上 1,3. 再将 i 的值写入内存。这种其实就是违背直觉的地方。

我们再将分配时间片和 CPU 指令结合来看,因为线程所分配时间片长度的不确定性,所以每一条线程具体执行到哪个地方其实我们是不知道的,这时候如果有两个线程去争抢三个指令的操作过程,就会有可能导致线程 A 获取到执行权并读取了第一步中 i 变量的值,这时候 CPU 又将操作权给了线程 B,线程 B 从又执行了第一中读取变量 i 的值,这时候两者读取的值同是 0,那最后两个线程各自执行第二步,每个线程中 i 的值都是 1,

所以我们解决原子性问题就是需要从高级语言层面来解决这种差异性,Java 中就是使用了 synchronizedLock 接口来解决问题。

3. 有序性问题

程序的结果依赖代码的执行顺序,而编译器有可能会优化这一顺序,所以可能会导致程序的结果不符目标结果。
导致原因:编译优化

在平常编写的程序中,编译器并不一定会一定按照程序的语句执行,而是有可能对程序语句进行优化,虽然编译优化的原则是会对没有数据依赖关系的语句做重排序,但是,这只限制在单线程程序里面没有问题,而如果是多线程的程序,因为不同的线程在不同的 CPU 中,导致单独 CPU 中的程序重排序没问题,但是两个 CPU 结合来看,编译重排序就会出现程序的指令顺序不符合我们想要的顺序。

  • 4
    点赞
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
1. 数据库事务是指一组数据库操作,这些操作要么全部成功执行,要么全部回滚。事务具有以下特性: - 原子性(Atomicity):事务中的操作要么全部执行成功,要么全部回滚,不会出现部分操作成功的情况。 - 一致性(Consistency):事务在执行前后,数据库的状态必须保持一致。如果事务执行失败,则数据库回滚到事务开始前的状态。 - 隔离性(Isolation):并发执行的事务之间应该相互隔离,一个事务不应该影响其他事务的执行结果。 - 持久性(Durability):一旦事务提交成功,其对数据库的修改就应该是永久性的,即使发生系统故障也不应该丢失。 2. 数据库索引是一种数据结构,用于提高数据库查询的性能。它可以加快数据的查找速度,减少磁盘I/O操作。索引的优点是: - 加快数据的查询速度。 - 减少磁盘I/O操作。 - 可以通过索引来保证数据的完整性和一致性。 索引的缺点是: - 占用额外的存储空间。 - 在插入、更新和删除数据时需要维护索引,影响写操作的性能。 示例:在一个学生信息表中,可以创建一个基于学生学号的索引,以加快根据学号查询学生信息的速度。 3. 关系数据库(Relational Database)是基于关系模型的数据库,使用表格来存储和组织数据。每个表格表示一个实体,每个实体有多个属性。关系数据库适用于结构化数据,适合用于复杂查询和事务处理。例如,MySQL、Oracle等。 非关系数据库(Non-relational Database)是指不使用表格的数据库,而是使用其他数据模型来存储和组织数据,例如键值对、文档、图形等。非关系数据库适用于非结构化、半结构化或大规模分布式数据。例如,MongoDB、Redis等。 场景举例: - 关系数据库适合存储金融交易记录、学生信息等结构化数据,并且需要支持复杂查询和事务处理的场景。 - 非关系数据库适合存储日志数据、社交媒体数据等非结构化或半结构化数据,并且需要高可扩展性和性能的场景。 4. 数据库范式是一种设计规范,用于消除冗余数据并提高数据库的性能和数据完整性。常见的三个范式如下: - 第一范式(1NF):要求每个字段都是原子性的,不可再分。确保每个字段只包含一个值。 - 第二范式(2NF):在满足1NF的基础上,要求非主键字段完全依赖于主键,而不是部分依赖。 - 第三范式(3NF):在满足2NF的基础上,要求非主键字段之间不存在传递依赖,即不存在非主键字段依赖于其他非主键字段。 范式的作用和优势包括: - 数据结构更清晰,减少了数据冗余,节省存储空间。 - 提高数据更新的速度和效率。 - 提高数据的一致性和完整性。 5. ACID是数据库事务的四个属性: - 原子性(Atomicity):事务中的操作要么全部成功执行,要么全部回滚。 - 一致性(Consistency):事务在执行前后,数据库的状态必须保持一致。 - 隔离性(Isolation):并发执行的事务之间应该相互隔离,一个事务不应该影响其他事务的执行结果。 - 持久性(Durability):一旦事务提交成功,其对数据库的修改就应该是永久性的。 6. 数据库的锁机制用于控制并发操作时的数据访问。常见的数据库锁包括: - 共享锁(Shared Lock):允许多个事务同时对同一数据进行读操作,但不允许写操作。 - 排他锁(Exclusive Lock):在事务对数据进行写操作时,其他事务不能对该数据进行读或写操作。 - 行级锁(Row-level Lock):对数据库中的行进行锁定,粒度更细,可以减少锁冲突。 - 表级锁(Table-level Lock):对整个表进行锁定,粒度较大,可能造成锁冲突。 例如,在一个银行转账的场景中,可以使用排他锁来确保同一时间只有一个事务可以修改账户余额。 7. SQL的JOIN操作用于将多个表格中的数据连接起来。常见的JOIN类型包括: - INNER JOIN:返回两个表中匹配的行。 - LEFT JOIN:返回左表中所有的行,以及与右表匹配的行。 - RIGHT JOIN:返回右表中所有的行,以及与左表匹配的行。 - FULL JOIN:返回左表和右表中所有的行。 这些JOIN类型之间的区别在于返回的结果集中是否包含没有匹配的行。 8. 当数据库查询出现性能问题时,可以采取以下措施进行优化: - 优化查询语句,使用索引、合理设计表结构。 - 分析和调整数据库的配置参数。 - 增加硬件资源,例如增加内存、优化磁盘配置。 - 使用数据库缓存,减少对数据库的访问次数。 - 对数据库进行分区、分表,提高查询效率。 - 使用异步操作、并发访问等技术提高系统的并发处理能力。 9. 备份和恢复数据库是保证数据安全的重要手段。常见的备份和恢复方法包括: - 完全备份(Full Backup):备份整个数据库,包括所有数据和日志。 - 增量备份(Incremental Backup):备份自上次备份以来发生的变化部分。 - 差异备份(Differential Backup):备份自上次完全备份以来发生的变化部分。 - 日志备份(Log Backup):备份事务日志,用于恢复到指定时间点或事务。 - 数据库恢复:根据备份文件进行数据的还原和恢复。 这些方法各有优缺点,完全备份可恢复性强但占用存储空间大,增量备份和差异备份则可以减少存储空间占用。 10. 视图(View)是虚拟的表,它是基于一个或多个表的查询结果构建的。视图不包含实际的数据,而是根据查询语句动态生成数据。视图的优势和用途包括: - 简化复杂查询:可以将复杂的查询语句封装成一个视图,简化用户的查询操作。 - 数据安全性:可以通过视图来限制用户对数据的访问权限,只暴露部分数据给用户。 - 数据逻辑独立性:可以通过视图来隐藏底层数据的结构和关系,提高应用程序的稳定性。 - 数据重用:可以将常用的查询逻辑封装成视图,提高代码的重用性。 总之,视图提供了一种抽象层,使得用户可以以更简洁、安全和方便的方式来访问数据库中的数据。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

瞎叨叨的一天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值