20191302 第四章学习笔记

并发编程

摘要

• 本章论述了并发编程,介绍了并行计算的概念,指出了并行计算的重要性;
• 比较了顺序算法与并行算法,以及并行性与并发性;
• 解释了线程的原理及其相对于进程的优势;
• 通过示例介绍了 Pthread 中的线程操作,包括线程管理函数,互斥量、连接、条件变量和屏障等线程同步工具;
• 通过具体示例演示了如何使用线程进行并发编程,包括矩阵计算、快速排序和用并发线程求解线性方程组等方法;
• 解释了死锁问题,并说明了如何防止并发程序中的死锁问题;
• 讨论了信号量,并论证了它们相对于条件变量的优点。

并行性和并发性

• 真正的并行执行只能在多个处理组件的系统中实现，比如多处理器或多核系统。
• 在单CPU系统中，并发性是通过多任务处理实现的。

线程

• 线程的原理
  • 在内核模式下，各进程在唯一地址空间上执行，与其他进程是分开的；
  • 每个进程都是一个独立单元，只有一个执行路径;
  • 线程是某进程同一地址空间上的独立执行单元,如果只有一个主线程，那么进程和线程并没有什么本质区别。
• 线程的优点
  1. 线程创建和切换速度更快。
  2. 线程的响应速度更快。
  3. 线程更适合并行计算
• 线程的缺点
  1. 由于地址空间共享，线程需要来自用户的明确同步。
  2. 许多库函数可能对线程不安全。
  3. 在单CPU系统上，使用线程解决间题实际上要比使用顺序程序慢，这是由在运行时创建线程和切换上下文的系统开销造成的。
• 线程操作
  • 线程可在内核模式或用户模式下执行。
  • 在用户模式下，线程在进程的相同地址空间中执行，但每个线程都有自己的执行堆栈。
  • 线程是独立的执行单元，可根据操作系统内核的调度策略，对内核进行系统调用，变为桂起激活以继续执行等。
  • 为了利用线程的共享地址空间，操作系统内核的调度策略可能会优先选择同一进程中的线程，而不是不同进程中的线程。
• 线程管理函数
  • Pthread库提供了用于线程管理的以下API

    pthread_create(thread, attr, function, arg): create thread
    pthread_exit(status）：terminate thread
    pthread_cancel(thread) : cancel thread
    pthread_attr_init(attr) : initialize thread attributes
    pthread_attr_destroy(attr): destroy thread attribute
    

  • 创建线程
    • 使用pthread_create()函数创建线程。
      int pthread_create (pthread_t *pthread_id,pthread_attr_t *attr,void * (*func) (void *), void *arg);
    • 其中，attr最复杂，其使用步骤为
      1. 定义一个pthread属性变址pt:hread_attr_tattr。
      2. 用pthread_attr_init(&attr)初始化屈性变掀。
      3. 设置属性变垃并在pthread_create()调用中使用。
      4. 必要时，通过pthread_attr_destroy(&attr)释放attr资源。
  • 线程终止
    • 线程函数结束后，线程即终止，或者，线程可以调用函数int pthraad_exit {void *status)进行显式终止，其中状态是线程的退出状态。
  • 线程连接
    • 一个线程可以等待另一个线程的终止， 通过：
      int pthread_join (pthread_t thread, void **status__ptr);
    • 终止线程的退出状态以status_ptr返回。

线程同步

• 当多个线程试图修改同一共享变量或数据结构时，如果修改结果取决于线程的执行顺序，则称之为竞态条件。

• 互斥量

  • 在 Pthread中，锁被称为互斥量，意思是相互排斥。
  • 互斥变呈是用 ptbread_mutex_t类型声明的在使，用之前必须对它们进行初始化。
    • 有两种方法可以初始化互斥址：
      1. 静态方法:pthreaa—mutex_t m = PTHREAD_MUTEX_INITIALIZER,定义互斥量 m, 并使用默认属性对其进行初始化。
      2. 动态方法，使用 pthread_ mutex _init() 函数
  • 线程通过互斥量来保护共享数据对象

• 死锁预防

  • 死锁是一种状态，在这种状态下，许多执行实体相互等待，因此都无法继续下去。
  • 死锁预防，试图在设计并行算法时防止死锁的发生。
  • 一种简单的死锁预防方法是对互斥量进行排序，并确保每个线程只在一个方向请求互斥量，这样请求序列中就不会有循环。

• 条件变量

  • 条件变量提供了一种线程协作的方法。
  • 在Pthread中，使用类型pthread_cond_t来声明条件变量，而且必须在使用前进行初始化。
  • 与互斥变量一样，条件变量也可以通过两种方法进行初始化。
    • 静态方法:pthread_cond_t con= PTHREAD_COND_INITIALIZER;定义一个条件变屾con,并使用默认属性对其进行初始化。
    • 动态方法:使用pthread_cond_init()函数，可通过attr参数设置条件变量。为简便起见，我们总是使用NULLattr参数作为默认属性。

• 信号量

  • 信号量是进程同步的一般机制。
  • 信号量是一种数据结构

    struct sem{
      int value;
      struct process *queue
    }s;
    

问题与解决

• 并行性和并发性的区别与联系
  • 并发的实质是一个物理CPU(也可以多个物理CPU) 在若干道程序之间多路复用；
    • 所有的并发处理都有排队等候，唤醒，执行至少三个这样的步骤；
  • 并发性，又称共行性，是指能处理多个同时性活动的能力；
    • 并发性是对有限物理资源强制行使多用户共享以提高效率。
  • 并行性指两个或两个以上事件或活动在同一时刻发生。在多道程序环境下，并行性使多个程序同一时刻可在不同CPU上同时执行。
  • 并行是指同时发生的两个并发事件，具有并发的含义，而并发则不一定并行，也亦是说并发事件之间不一定要同一时刻发生。

实践

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
typedef struct{
	int upperbound;
	int lowerbound;
}PARM;
#define N 10
int a[N]={5,1,6,4,7,2,9,8,0,3};// unsorted data
int print(){//print current a[] contents
	int i;
	printf("[");
	for(i=0;i<N;i++)
		printf("%d ",a[i]);
	printf("]\n");
}
void *Qsort(void *aptr){
	PARM *ap, aleft, aright;
	int pivot, pivotIndex,left, right,temp;
	int upperbound,lowerbound;
	pthread_t me,leftThread,rightThread;
	me = pthread_self();
	ap =(PARM *)aptr;
	upperbound = ap->upperbound;
	lowerbound = ap->lowerbound;
	pivot = a[upperbound];//pick low pivot value
	left = lowerbound - 1;//scan index from left side
	right = upperbound;//scan index from right side
	if(lowerbound >= upperbound)
		pthread_exit (NULL);
	while(left < right){//partition loop
		do{left++;} while (a[left] < pivot);
		do{right--;}while(a[right]>pivot);
		if (left < right ) {
			temp = a[left];a[left]=a[right];a[right] = temp;
		}
	}
	print();
	pivotIndex = left;//put pivot back
	temp = a[pivotIndex] ;
	a[pivotIndex] = pivot;
	a[upperbound] = temp;
	//start the "recursive threads"
	aleft.upperbound = pivotIndex - 1;
	aleft.lowerbound = lowerbound;
	aright.upperbound = upperbound;
	aright.lowerbound = pivotIndex + 1;
	printf("%lu: create left and right threadsln", me) ;
	pthread_create(&leftThread,NULL,Qsort,(void * )&aleft);
	pthread_create(&rightThread,NULL,Qsort,(void *)&aright);
	//wait for left and right threads to finish
	pthread_join(leftThread,NULL);
	pthread_join(rightThread, NULL);
	printf("%lu: joined with left & right threads\n",me);
}
	int main(int argc, char *argv[]){
	PARM arg;
	int i, *array;
	pthread_t me,thread;
	me = pthread_self( );
	printf("main %lu: unsorted array = ", me);
	print( ) ;
	arg.upperbound = N-1;
	arg. lowerbound = 0 ;
	printf("main %lu create a thread to do QS\n" , me);
	pthread_create(&thread,NULL,Qsort,(void * ) &arg);//wait for Qs thread to finish
	pthread_join(thread,NULL);
	printf ("main %lu sorted array = ", me);
	print () ;
}

• 运行结果