多线程编程

关于线程：

1、线程是调度的基本单位

2、进程是系统分配资源的基本单位

3、线程是在进程内部（地址空间）运行的

4、在Linux下，使用进程模拟线程，并没有真正意义上的线程，也称轻量级进程（LWP）

5、线程之间共享的部分：

地址空间、函数调用、全局变量、文件描述符表、每种信号的处理方式、当前工作目录、用户id,组id

6、线程私有：

线程ID、上下文各种寄存器的值（当再次切换调度时可恢复）、栈空间

7、线程的操作：

(1)线程的创建： 使用函数pthread_create()，原型为：int pthread_create(pthread_t restrict tidp,const pthread_attr_t *restrict_attr,void(start_rtn)(void),void *restrict arg);

若成功则返回0，否则返回出错误码；

第一个参数为指向线程标识符的指针。

第二个参数用来设置线程属性。

第三个参数是线程运行函数的起始地址。

第四个参数是运行函数的参数。

(2)线程等待：使用函数pthread_join();原型为：

int pthread_join(pthread_t thread, void **retval);

若成功则返回0，否则返回出错误码；

#include<stdio.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>

void* thread_run(void* arg)
{
int i = 5000;
while(i--)
{
printf("newThreadtid:%lu,pid:%d\n",pthread_self(),get          pid());
sleep(1);
}
return 0;
}
int main()
{
pthread_t id;
int ret = pthread_create(&id,NULL,thread_run,NULL);
if(ret!=0)
{
printf("%d,%s\n",ret,strerror);
}
int count = 0;
while(count++<5)
{
printf("mainThreadtid:%lu,pid:%d\n",pthread_self(),getpid());
sleep(1);
}
return 0;
}

(3)线程终止：

a: 从线程函数return。这种⽅法对主线程不适用,从main函数return相当于调⽤exit。

b: ⼀个线程可以调⽤pthread_cancel终⽌止同⼀进程中的另⼀个线程。

c:线程可以调用pthread_exit终⽌止⾃己。

d:不能调用exit();exit是用来结束进程的。

#include<stdio.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>
void* thread_run(void* arg)
{
int i = 5000;
while(i--)
{
printf("newThread tid :%lu,pid:%d\n",pthread_self(),getpid());
sleep(1);
printf("thread %lu count is %d\n",pthread_self(),count);
}
pthread_cancel(pthread_self());
//pthread_exit((void*)234);
//exit(1);
//return (void*)33;

}
int main()
{
pthread_t id;
int ret = pthread_create(&id,NULL,thread_run,NULL);
if(ret!=0)
{
printf("%d,%s\n",ret,strerror);
}
int count = 0;
while(count++<5)
{
printf("mainThread tid :%lu,pid:%d\n",pthread_self(),getpid());
sleep(1);
}
void* val;
pthread_join(id,&val);
printf("%d\n",val);
printf("newthread was quit,mainthread is ready to quit\n");
return 0;
}

调用exit:



从线程函数return:



调用pthread_exit():



(4)线程的分离：detached,创建出的线程默认可结合的，此时必须有特定的线程等待它回收资源，线程是可分离的，不需要等待，最后由系统回收资源；

(5)线程的互斥：

多个线程同时访问共享数据时可能会冲突,这跟前面讲信号时所说的可重⼊性是同样的问

题。⽐如 两个线程都要把某个全局变量增加1,这个操作在某平台需要三条指令完成:

1. 从内存读变量值到寄存器

2. 寄存器的值加1

3. 将寄存器的值写回内存

假设两个线程在调度切换时执⾏这三条指令,则可能导致最后变量只加了⼀次⽽非两次。我们创建两个线程,各⾃自把count增加5000次,正常情况下最后count应该等于10000,但事实上每次运行该程序的结果都不一样,有时候数到5000多,有时候数到6000多。

#include<stdio.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>

int count = 0;
void* thread_run(void* arg)
{
int i = 5000;
int val = 0;
while(i--)
{
int val = count;
printf("thread %lu count is %d\n",pthread_self(),count);
count = val+1;
}
return 0;
}
int main()
{
pthread_t id1;
pthread_t id2;
pthread_create(&id1,NULL,thread_run,NULL);
pthread_create(&id2,NULL,thread_run,NULL);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
printf("count is %d\n",count);
return 0;
}

对于多线程的程序,访问冲突的问题是很普遍的,解决的办法是引入互斥锁(Mutex,MutualExclusive Lock),获得锁的线程可以完成“读-修改-写”的操作,然后释放锁给其它线程,没有获得锁的线程只能等待而不能访问共享数据,这样“读-修改-写”三步操作组成⼀个原⼦子操作,要么都执⾏,要么都不执行,不会执⾏到中间被打断,也不会在其它处理器上并行做这个操作。

//申请互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int count = 0;
void* thread_run(void* arg)
{
int i = 5000;
int val = 0;
while(i--)
{
//加锁
pthread_mutex_lock(&mutex);
int val = count;
printf("thread %lu count is %d\n",pthread_self(),count);
count = val+1;
//解锁
pthread_mutex_unlock(&mutex);
}

return 0;
}
int main()
{
pthread_t id1;
pthread_t id2;
pthread_create(&id1,NULL,thread_run,NULL);
pthread_create(&id2,NULL,thread_run,NULL);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
printf("count is %d\n",count);
pthread_mutex_destroy(&mutex);
return 0;
}