UC编程之线程

线程--隶属于进程，是进程中的程序流。操作系统支持多进程，每个进程内部支持多线程。多线程并行(同时执行)代码。

进程--重量级的，每个进程都需要独立的内存空间。

线程--轻量级的，线程不拥有独立的内存资源，共享所在进程的内存资源，

但每个线程都拥有一个独立的栈区。

开发程序中，多线程使用的概率更高。

进程中可以有多个线程，但必须有一个主线程(main函数)。

由于CPU不可分，真正意义的并行其实不存在的，针对时间点的并行是不存在

的。人的感官都是针对时间段(很少)。主流的操作系统都是使用CPU时间片的

方式实现并行。每个CPU时间片都是极少的CPU运行时间。

多线程编程有一套成形的API，属于POSIX规范。

POSIX规范提供了一个头文件pthread.h 和一个共享库文件lib pthread.so。

因此在编写多线程代码时需要#include<pthread.h>，链接时需要加 -l pthread

或 -pthread

如何创建线程？

关于线程的大多数函数/成员变量都是以pthread_开头。

int pthread_create(pthread_t *id, const pthread_attr_t *attr,

void *(fa) (void *), void *p)

参数id用于存储新建线程的ID

attr用于传入新建线程的属性，一般0即可

fa是函数指针，线程执行的代码写成函数fa并在创建线程时传入

p是fa的参数，如果不需要0即可

注意：线程的错误处理不使用errno，而是直接返回。

当同一进程内部有多线程时，每个线程内部的代码顺序执行，而多线程之间的

代码乱序执行。

多线程之间 相互独立，但也相互影响。

主线程结束，进程随之结束;进程结束，进程中所有线程都结束。

pthread_join函数挂起当前线程直到所等待的线程结束。

线程的参数由 pthread_create的第4个参数传入，返回值由pthread_join的第二

个参数获取。

函数pthread_exit(void*)也可以退出线程并且也有返回值(参数void*就是线程的

返回值)

函数exit()退出的是进程(所有线程)，pthread_exit()退出单个线程。

线程的运行有两种状态：

非分离状态--可以用函数pthread_join

分离状态 --可以用函数pthread_detach

两者的区别：

非分离状态的线程资源回收要到pthread_join函数结束以后;分离状态的线程资源马上回收。处于分离状态的线程无法join(join没效果)

经验：线程启动后，最好设置join或者detach

实例：

创建线程：

1 #include<stdio.h>

2 #include<pthread.h>

3

4 void* task(void* p){

5   int i;

6   for(i=0;i<100;i++){

7     printf("i=%d\n",i);

8   }

9 }

10

11

12 int main(){//主线程

13     pthread_t id;

14     pthread_create(&id,0,task,0);//创建线程

15     int i;

16     for(i=0;i<100;i++){

17       printf("main=%d\n",i);

18     }

19      sleep(1);

20      pthread_t id2 = pthread_self();//取当前线程

21      printf("id=%u,id2=%u\n",id);

22     return 0;

23 }

等待线程(pthread_join):

1 #include<stdio.h>

2 #include<pthread.h>

3

4 void* task(void* p){

5   int* pi = p;

6   printf("*pi=%d\n",*pi);

7   *pi =200;

8 }

9 int main(){//主线程

10     pthread_t id1;

11     int x =100;

12     pthread_create(&id1,0,task,&x);//创建线程

13     pthread_join(id1,0);//主线程等待id1的结束

14     printf("x=%d\n",x);

15     return 0;

16 }

1 #include<stdio.h>

2 #include<stdlib.h>

3 #include<pthread.h>

4

5 void* task(void* p){

6   printf("%d\n",(int)p);

7

8 }

9 void* task2(void* p){

10   sleep(1);

11   int* pi = p;

12   printf("*pi=%d\n",*pi);

13 }

14 int main(){

15   pthread_t id;

16   int x = 100;

17   pthread_create(&id,0,task,(void*)x);

18   pthread_join(id,0);

19   int* pi = malloc(4);

20   *pi=300;

21   pthread_create(&id,0,task2,pi);

22   free(pi);//free()释放掉了pi,使pi无效，传入task2将无效

23   pthread_join(id,0);

24   return 0;

25  }

线程的取消--线程可以被其他线程取消，有一套API（了解）

1 #include <stdio.h>

2 #include <pthread.h>

3 void* task1(void *p){//线程2取消线程1

4   //设置可以取消

5   pthread_setcancelstate(//换成DISABLE不能取消

6     PTHREAD_CANCEL_ENABLE,0);

7   //设置取消方式： 立即/下一个取消点

8   pthread_setcanceltype(//立即,DEFERRED下一个

9    PTHREAD_CANCEL_DEFERRED/*ASYNCHRONOUS*/,0);

10   while(1) {

11     printf("I am superman!\n");

12     usleep(1); } }

13 void* task2(void *p){

14   sleep(3); printf("开始取消线程1\n");

15   pthread_cancel(*(pthread_t*)p);  }

16 int main(){

17   pthread_t id1,id2;

18   pthread_create(&id1,0,task1,0);

19   pthread_create(&id2,0,task2,&id1);

20   pthread_join(id1,0); pthread_join(id2,0);

21   return 0;

22 }

线程同步--因为多线程之间共享进程的资源，多个线程同时访问相同的资源时需要互相协调，以防止数据出现不一致、不完整的问题，线程之间的协调和通信叫线程同步。

线程同步有很多解决方案：

线程同步的思路：访问共享资源时，不能并行，而是串行(一个一个的访问)

pthread中，提供了互斥量(互斥锁)实现线程同步。

互斥量的使用步骤：

1 定义互斥量 pthread_mutex_t lock;

2 初始化互斥量，方法有二：

pthread_mutex_init(&lock,0);

或者在定义的时候用宏同时赋值：

pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

3 加上互斥锁(给访问共享资源的代码加)

pthread_mutex_lock(&lock)

4 访问

5 解锁  pthread_mutex_unlock(&lock)

6 释放互斥锁的资源

pthread_mutex_destroy(&lock)

互斥量实例：

1 #include<stdio.h>

2 #include<pthread.h>

3

4 char* data[5];//存数据

5 int size = 0; //人数

6

7 pthread_mutex_t lock; //1 定义

8 //= PTHREAD_MUTEX_INITIALIZER;

9

10 void* task(void* p){

11  pthread_mutex_lock(&lock);//3 上锁

12  data[size] = (char*)p;

13  usleep(100000);

14  size++;

15  pthread_mutex_unlock(&lock);//4 解锁

16 }

17

18 int main(){

19   pthread_mutex_init(&lock,0);//2 初始化

20   data[size] = "zhangfei";

21   size++;

22   pthread_t id1,id2;

23   pthread_create(&id1,0,task,"guanyu");

24   pthread_create(&id2,0,task,"zhaoyun");

25   pthread_join(id1,0);

26   pthread_join(id2,0);

27   int i;

28   for(i=0;i<size;i++){

29    printf("%s\n",data[i]);

30   }

31   pthread_mutex_destroy(&lock);

32   return 0;

33 }

信号量-- 就是一个计数器，控制同时访问共享资源的线程/进程数量。

如果信号量为1,效果等同于互斥量。

信号量的使用，已经有了固定的API，步骤：

1 定义一个信号量(semaphore)

sem_t sem;

信号量不属于pthread.h

2 初始化信号量

sem_init(&sem,0,最大值);

第二个参数必须是0,0代表控制线程，其他值代表控制进程，Linux只支持线程。

第三个参数就是计数的初始值，为1信号量的作用等价于互斥量。

3 获取一个信号量(信号量减1)

sem_wait(&sem);

4 访问共享资源

5 释放一个信号量(信号量加1)

sem_post(&sem)

6 如果不再使用，可以删除信号量

sem_destroy(&sem)

信号量实现线程同步实例：

1 #include<stdio.h>

2 #include<pthread.h>

3 #include<semaphore.h>

4

5 char* data[5];//存数据

6 int size = 0; //人数

7

8 sem_t sem; //1 定义

9

10 void* task(void* p){

11  sem_wait(&sem);//3 上锁

12  data[size] = (char*)p;

13  usleep(100000);

14  size++;

15  sem_post(&sem);//4 解锁

16 }

17

18 int main(){

19   sem_init(&sem,0,1);//2 初始化

20   data[size] = "zhangfei";

21   size++;

22   pthread_t id1,id2;

23   pthread_create(&id1,0,task,"guanyu");

24   pthread_create(&id2,0,task,"zhaoyun");

25   pthread_join(id1,0);

26   pthread_join(id2,0);

27   int i;

28   for(i=0;i<size;i++){

29    printf("%s\n",data[i]);

30   }

31   sem_destroy(&sem);

32   return 0;

33 }

练习：

控制访问数据库的最大的并行线程数量

数据库最多运行10个线程同时访问，启动20个线程，看一下信号量控制效果

1 #include<stdio.h>

2 #include<pthread.h>

3 #include<semaphore.h>

4

5 sem_t sem;

6 void* task(void* p){

7     int i =(int)p;

8     printf("第%d个线程启动，申请连接\n",i);

9     sem_wait(&sem);

10     printf("第%d个线程申请成功\n",i);

11     sleep(10);

12     printf("第%d个线程完成连接\n",i);

13     sem_post(&sem);

14 }

15 int main(){

16     sem_init(&sem,0,10);//初始化

17     int i;

18     for(i = 0;i<20;i++){

19        pthread_t id;

20        pthread_create(&id,0,task,(void*)(i+1));

21     }

22     while(1);

23 //  sem_destroy(&sem);

24     return 0;

25 }

死锁：线程之间互相锁定，导致所有线程都无法运行。多线程一定要避免锁死

避免死锁的经验：

顺序上锁，反向解锁，不要回调。

thread1:

lock(&mutex1);

...//1

lock(&mutex2);//3  thread1阻塞等待mutex2

...

unlock(&mutex2);

...

unlock(&mutex1);

thread2:

lock(&mutex2);//2

...//4

lock(&mutex1);//5 thread2阻塞等待mutex1

...

unlock(&mutex1);

...

unlock(&mutex2);

thread1运行到lock(&mutex2)时，如果thread2已经运行了lock(&mutex2)则thread1将阻塞等待thread2，thread2运行到lock(&mutex1);时，因为thread1已经运行了lock(&mutex1);thread2将阻塞等待thread1，结构thread1和thread2都将永远等待对方，无法结束，形成死锁