并发

若我们谈及计算机系统中的并发，则是指同一个系统中，多个独立活动同时进行，而非依次进行。起初的计算机并发只是一种制造并发的假象，因为只有一个处理器，在同一时刻实质只能处理一个任务，不过是一秒钟内进行多个任务的切换。看起来是同时进行的，因此叫做任务交换。

多年来，配备了多处理器的计算机一直被用作服务器，它要承担高性能的计算任务；现今，基于一芯多核处理器（简称多核处理器）的计算机日渐普及，多核处理器也用在台式计算机上。

无论是装配多个处理器，还是单个多核处理器，或是多个多核处理器，这些计算机都能真正并行运作多个任务，我们称之为硬件并发（hardware concurrency）。

并发方式

多进程并发

在应用软件内部，一种并发方式是，将一个应用软件拆分成多个独立进程同时运行，它们都只含单一线程，非常类似于同时运行浏览器和文字处理软件。这些独立进程可以通过所有常规的进程间通信途径相互传递信息（信号、套接字、文件、管道等）。

多线程并发

另一种并发方式是在单一进程内运行多线程。线程非常像轻量级进程，每个线程都独立运行，并能各自执行不同的指令序列。

不过，同一进程内的所有线程都共用相同的地址空间，且所有线程都能直接访问大部分数据。全局变量依然全局可见，指向对象或数据的指针和引用能在线程间传递。

尽管进程间共享内存通常可行，但这种做法设置复杂，往往难以驾驭，原因是同一数据的地址在不同进程中不一定相同。

并发与并行的区别

  • 并发（concurrency）：把任务在不同的时间点交给处理器进行处理。在同一时间点，任务并不会同时运行。
  • 并行（parallelism）：把每一个任务分配给每一个处理器独立完成。在同一时间点，任务一定是同时运行。

并发产生的原因

现在的 Linux 系统并发产生的原因很复杂，总结一下有下面几个主要原
因：
①、多线程并发访问， Linux 是多任务(线程)的系统，所以多线程访问是最基本的原因。
②、抢占式并发访问，从 2.6 版本内核开始， Linux 内核支持抢占，也就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程。
③、中断程序并发访问。
④、 SMP(多核)核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并发访问

并发访问带来的问题就是竞争，对于临界区必须保证一次只有一个线程访问，也就是要保证临界区是原子访问的，原子访问就表示这一个访问是一个步骤，不能再进行拆分。

任意时刻，单处理器系统都只能执行一个进程的代码，当操作系统决定要把控制权从当前进程转移到某个新进程时，就会进行上下文转换，即保存当前进程的上下文，回复进程的上下文，然后将控制权传递到新进程，新进程就会从它上次停止的地方开始。

从一个进程到另一个进程的转换是由操作系统内核管理的，内核是操作系统代码常驻主存的部分。

临界资源和临界区

1.临界资源
临界资源是一次仅允许一个进程使用的共享资源。各进程采取互斥的方式，实现共享的资源称作临界资源。属于临界资源的硬件有，打印机，磁带机等；软件有消息队列，变量，数组，缓冲区等。诸进程间采取互斥方式，实现对这种资源的共享。

2.临界区：
每个进程中访问临界资源的那段代码称为临界区（criticalsection），每次只允许一个进程进入临界区，进入后，不允许其他进程进入。不论是硬件临界资源还是软件临界资源，多个进程必须互斥的对它进行访问。多个进程涉及到同一个临界资源的的临界区称为相关临界区。使用临界区时，一般不允许其运行时间过长，只要运行在临界区的线程还没有离开，其他所有进入此临界区的线程都会被挂起而进入等待状态，并在一定程度上影响程序的运行性能。

原子操作

原子整形操作API函数

Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，此结构体定义在 include/linux/types.h 文件中，定义如下： 

1
2
3
175 typedef struct {
176 int counter;
177 } atomic_t;

如果要使用原子操作 API 函数，首先要先定义一个 atomic_t 的变量 

1
2
atomic_t a;//定义a
atomic_t b = ATOMIC_INIT(0);//定义原子变量b并赋值0；使用的是ATOMIC_INIT宏

如果使用 64 位的 SOC 的话，就要用到 64 位的原子变量， Linux 内核也定义了 64 位原子结构体，如下所示： 

1
2
3
typedef struct {
long long counter;
} atomic64_t;

相应的也提供了 64 位原子变量的操作 API 函数，这里我们就不详细讲解了，和表 47.2.1.1中的 API 函数有用法一样，只是将“atomic_”前缀换为“atomic64_”，将 int 换为 long long。如果使用的是 64 位的 SOC，那么就要使用 64 位的原子操作函数。

原子位操作 API 函数

Linux 内核也提供了一系列的原子位操作 API 函数，只不过原子位操作不像原子整形变量那样有个 atomic_t 的数据结构，原子位操作是直接对内存进行操作 .

函数 描述
void set_bit(int nr, void *p) 将 p 地址的第 nr 位置 1
void clear_bit(int nr, void *p) 将 p 地址的第 nr 位清零。
void change_bit(int nr, void *p) 将 p 地址的第 nr 位进行翻转
int test_bit(int nr, void *p) 获取 p 地址的第 nr 位的值。
int test_and_set_bit(int nr, void *p) 将 p 地址的第 nr 位置 1，并且返回 nr 位原来的值
int test_and_clear_bit(int nr, void *p) 将 p 地址的第 nr 位清零，并且返回 nr 位原来的值
int test_and_change_bit(int nr, void *p) 将 p 地址的第 nr 位翻转，并且返回 nr 位原来的值

自旋锁

当一个线程要访问某个共享资源的时候首先要先获取相应的锁， 锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程 A 持有，线程 B 想要获取自旋锁，那么线程 B 就会处于忙循环-旋转-等待状态，线程 B 不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里“转圈圈”的等待锁可用。

自旋锁的一个缺点：那就等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。所以自旋锁适用于短时期的轻量级加锁，如果遇到需要长时间持有锁的场景那就需要换其他的方法了，

Linux 内核使用结构体 spinlock_t 表示自旋锁 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
64 typedef struct spinlock {
65 union {
66 	struct raw_spinlock rlock;
67
68 	#ifdef CONFIG_DEBUG_LOCK_ALLOC
69 	# define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
70 	struct {
71 		u8 __padding[LOCK_PADSIZE];
72 		struct lockdep_map dep_map;
73 	};
74 	#endif
75 };
76 } spinlock_t;

spinlock_t lock;//定义自旋锁

自旋锁API函数

表中的自旋锁API 函数适用于SMP或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。自旋锁会自动禁止抢占，也就说当线程 A得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而
且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放，好了，死锁发生了！

表 中的 API 函数用于线程之间的并发访问，如果此时中断也要插一脚，中断也想访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC来说会有多个 CPU 核)，否则可能导致锁死现象的发生。

线程 A 先运行，并且获取到了 lock 这个锁，当线程 A 运行 functionA 函数的时候中断发生了，中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁，但是这个锁被线程 A 占有着，中断就会一直自旋，等待锁有效。但是在中断服务函数执行完之前，线程 A 是不可能执行的，线程 A 说“你先放手”，中断说“你先放手”，场面就这么僵持着，死锁发生！

最好的解决方法就是获取锁之前关闭本地中断， Linux 内核提供了相应的 API 函数

建议使用 spin_lock_irqsave/ spin_unlock_irqrestore，因为这一组函
数会保存中断状态，在释放锁的时候会恢复中断状态。一般在线程中使用 spin_lock_irqsave/spin_unlock_irqrestore，在中断中使用spin_lock/spin_unlock， 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1 DEFINE_SPINLOCK(lock) /* 定义并初始化一个锁 */
2 
3/* 线程 A */
4 void functionA (){
5 		unsigned long flags; /* 中断状态 */
6 		spin_lock_irqsave(&lock, flags) /* 获取锁 */
7 		/* 临界区 */
8 		spin_unlock_irqrestore(&lock, flags) /* 释放锁 */
9 }
10
11 /* 中断服务函数 */
12 void irq() {
13 spin_lock(&lock) /* 获取锁 */
14 /* 临界区 */
15 spin_unlock(&lock) /* 释放锁 */
16 }

自旋锁使用注意事项

①、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如稍后要讲的信号量和互斥体。
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。
③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己把自己锁死了！
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。

编写程序

使用自旋锁来实现对实现设备的互斥访问 ，其实是使用定义的自旋锁来保护设备状态的变量，在改变设备状态的变量前后使用上锁和解锁的操作，主要是通过判断自旋锁的设备状态变量实现设备的互斥访问。

信号量

信号量（semaphore）是操作系统用来解决并发中的互斥和同步问题的一种方法。
信号量是一个与队列有关的整型变量，你可以把它想象成一个数后面拖着一条排队的队列。

那信号量上面值n代表什么意思呢？
n>0：当前有可用资源，可用资源数量为n
n=0：资源都被占用，可用资源数量为0
n<0：资源都被占用，并且还有n个进程正在排队
那信号量拖着的那个队列就是用来放正在排队想要使用这一资源的进程。

信号量的特点：
①、因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合。
②、因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
③、如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。

信号量API函数

Linux 内核使用 semaphore 结构体表示信号量 

1
2
3
4
5
struct semaphore {
	raw_spinlock_t lock;
	unsigned int count;
	struct list_head wait_list;
};

1
2
3
4
5
struct semaphore sem; /* 定义信号量 */
sema_init(&sem, 1); /* 初始化信号量 */
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

互斥体

将信号量的值设置为 1 就可以使用信号量进行互斥访问了，虽然可以通过信号量实现互斥，但是 Linux 提供了一个比信号量更专业的机制来进行互斥，它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。在我们编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。

linux内核使用mutex结构体表示互斥体

1
2
3
4
5
struct mutex {
/* 1: unlocked, 0: locked, negative: locked, possible waiters */
atomic_t count;
spinlock_t wait_lock;
};

在使用 mutex 之前要先定义一个 mutex 变量。在使用 mutex 的时候要注意如下几点：
①、 mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
②、和信号量一样， mutex 保护的临界区可以调用引起阻塞的 API 函数。
③、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁

API函数

1
2
3
4
5
6
1 struct mutex lock; /* 定义一个互斥体 */
2 mutex_init(&lock); /* 初始化互斥体 */
3 
4 mutex_lock(&lock); /* 上锁 */
5 /* 临界区 */
6 mutex_unlock(&lock); /* 解锁 */