前言

Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用libpthread.a。Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork。

基础知识点和代码实现

1.运行一个进程中的多个线程，彼此之间使用相同的地址空间，共享大部分数据。

2.启动一个线程所花费的空间远远小于启动一个进程所话费的空间。

3.线程间切换所需要的时间远远小于进程间切换所需要的时间。

4.不同进程具有独立的数据空间，数据的传递只能通过通信的方式。--费时、不方便

5.编写多线程需要注意的地方：

6.多线程优点：

7. 进程是资源分配的基本单位，线程没什么资源。共享进程资源

8. volatile的作用是： 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值.

XBYTE[2]=0x55;
XBYTE[2]=0x56;
XBYTE[2]=0x57;
XBYTE[2]=0x58;

9.线程相关操作

    typedef unsigned long int pthread_t;

    9.2创建线程:pthread_creat

   原型为：

 extern int pthread_create _P((pthread_t *_thread,_const pthread_attr_t *_attr,void *(*_start_routine) (void *),void *_arg));

 线程创建成功，新创建线程运行参数三和参数四确定的函数。

    9.3等待线程结束pthread_join和线程结束pthread_exit

     pythread_join函数原型：   

   extern int pthread_join_P((pthread_t _th,void**_thread_return));

    线程结束有两种途径：函数结束，调用它的线程结束；另一种方式通过函数pthread_exit来实现。

exter void pthread_exit_P((void*_retval)_attribute_((_noreturn_));

唯一的参数是函数的返回代码：只要pthread_join中的第二个参数thread_return不是NULL，该值传递给thread_return。

10.线程的同步

    所谓的互斥就是线程之间互相排斥，获得资源的线程排斥其它没有获得资源的线程。Linux使用互斥锁来实现这种机制。

     既然叫锁，就有加锁和解锁的概念。当线程获得了加锁的资格，那么它将独享这个锁，其它线程一旦试图去碰触这个锁就立即被系统“拍晕”。当加锁的线程解开并放弃了这个锁之后，那些被“拍晕”的线程会被系统唤醒，然后继续去争抢这个锁。至于谁能抢到，只有天知道。但是总有一个能抢到。于是其它来凑热闹的线程又被系统给“拍晕”了……如此反复。

    从互斥锁的这种行为看，线程加锁和解锁之间的代码相当于一个独木桥，同意时刻只有一个线程能执行。从全局上看，在这个地方，所有并行运行的线程都变成了排队运行了。比较专业的叫法是同步执行，这段代码区域叫临界区。同步执行就破坏了线程并行性的初衷了，临界区越大破坏得越厉害。所以在实际应用中，应该尽量避免有临界区出现。实在不行，临界区也要尽量的小

   Linux初始化和销毁互斥锁的接口是pthread_mutex_init()和pthead_mutex_destroy()，对于加锁和解锁则有pthread_mutex_lock()、pthread_mutex_trylock()和pthread_mutex_unlock()。这些接口的完整定义如下：

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destory(pthread_mutex_t *mutex );
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

    互斥锁在同一个线程内，没有互斥的特性。也就是说，线程不能利用互斥锁让系统将自己“拍晕”。解释这个现象的一个很好的理由就是，拥有锁的线程把自己“拍晕”了，谁还能再拥有这把锁呢？但是另外情况需要避免，就是两个线程已经各自拥有一把锁了，但是还想得到对方的锁，这个时候两个线程都会被“拍晕”。一旦这种情况发生，就谁都不能获得这个锁了，这种情况还有一个著名的名字——死锁。死锁是永远都要避免的事情，因为这是严重损人不利己的行为。

    条件变量是一种事件机制。由一类线程来控制“事件”的发生，另外一类线程等待“事件”的发生。为了实现这种机制，条件变量必须是共享于线程之间的全局变量。而且，条件变量也需要与互斥锁同时使用。

int pthread_cond_init(pthread_cond_t *cond,
const pthread_condattr_t *attr);
int pthread_cond_destory(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond,
pthread_mutex_t *mutex,
const timespec *abstime);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);

这里插入一个简单多线程的例子：    

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


void *thread(void *arg)
{
 printf("This is a  thread and arg=%d.\n",*(int *)arg);
 *(int*)arg = 0;
 return arg;
}


int main(int argc,char *argv[])
{
 pthread_t th;
 int ret;
 int arg = 10;
 int *thread_ret = NULL;


  ret = pthread_create(&th,NULL,thread,&arg);
  if(ret!=0){
  printf("create thread error!\n");
  return -1;
}
        
cloud@zw:~$ gcc thread.c -o thread -lpthread
cloud@zw:~$ ./thread
This is the main process.
This is a  thread and arg=10.
thread_ret=0.

线程合并和线程分离都是用于回收线程资源的，可以根据不同的业务场景酌情使用。不管有什么理由，你都必须选择其中一种，否则就会引发资源泄漏的问题，这个问题与内存泄漏同样可怕。

12.两个多线程编程的例子和实现

  12.1） Linux里编写成多线程序，输出各线程号。

设计思路：今天看了老师的程序，明白了关于线程号输出函数pthread_self().很简单，我主要把多线程程序的主线程和子线程号进行输出。在过程中碰到问题，主线程号输出了，子线程号没有输出。仔细一想，主线程执行完了，子线程还没来得及执行就结束了。怎么办呢？sleep函数，让主线程等待10s，最终达到预期目的。

 程序如下：

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

void  * thread(void *arg)
{
        printf("thread id is %lu.\n",pthread_self());
        return NULL;
}

int main()
{
pthread_t id;
printf("Main thread id is %lu \n",pthread_self());
if(!pthread_create(&id,NULL,(void *)thread,NULL))
{
printf("succeed!\n");
sleep(10);
return 0;
}
else
{printf("Fail to Create Thread");
return -1;
}
}

运行结果：

注：编译的时候要链接库：gcc  -o thread1  thread1.c -lpthread

  12.2） 利用多线程计算pi值。

设计思路：这里利用中值积分定理来计算π值。我的思路就是把线程的执行任务分成四段，，每个线程执行一段，期间遇到的问题就是，线程传递的参数，有些没计算完，来不及传递过去，最终线程结束，我的做法就是让每个线程创建的时候，等待1s.最终达到我的预期结果。

程序如下：

#include <stdio.h>  
#include<pthread.h>  
static long num_steps=100000;   
const int numThreads = 4;  
double step, pi;  
pthread_mutex_t mut; 
double sum = 0.0;  
  
  
void * thread(void *pArg)   
{    
   double x;  
   int  i ;  
   int temp = *((int *)pArg);  
   int start = temp*(num_steps/4);  
   int end = start + num_steps/4;  
   printf("%d %d %d\n",temp,start,end);  //测试程序，可以去掉
   for (i=start; i<end; i++){  

      pthread_mutex_lock(&mut);
      x = (i+0.5)*step;  
      sum = sum + 4.0/(1.0 + x*x); 
      pthread_mutex_unlock(&mut); 
   }  
     
   return 0;   
}  
  
void main()  
{    
   int i;  
   pthread_t  hThread[numThreads];  
   pthread_mutex_init(&mut,NULL);
   step = 1.0/(double) num_steps;  
       
   for(i=0;i<numThreads;i++)  
   {  
      hThread[i] = pthread_create(&hThread[i] ,NULL,thread, &i);
      sleep(1);    
   }  
   
//  for(i=0;i<numThreads;i++){

  // pthread_join(hThread[i],NULL);
   
 //  }
  
   pi = step * sum;
   printf("Pi = %12.9f\n",pi);
   
     
}  

Linux 多线程编程