Linux多线程编程（1）

一个，什么是线程？

线程是进程的实体，并且是CPU调度和分配的基本单元. 它是一个基本单元，比流程小，可以独立运行. 线程本身基本上没有系统资源，只有少量操作上必不可少的资源（例如程序计数器，一组寄存器和堆栈），但是它可以与其他线程共享该进程拥有的所有资源到相同的过程.

二，何时使用多线程？当可以并行执行多个任务时，可以为每个任务启动一个线程.

三，线程创建使用pthread_create函数.

#include<pthread.h>
int pthread_create (pthread_t *__restrict __newthread,//新创建的线程ID
			  __const pthread_attr_t *__restrict __attr,//线程属性
			  void *(*__start_routine) (void *),//新创建的线程从start_routine开始执行
			  void *__restrict __arg)//执行函数的参数

返回值: 成功0，失败返回错误号，可以使用strerror（errno）函数获取错误信息

第四，线程的终止从执行函数返回线程的三种方式，返回值是线程的退出代码. 该线程被同一进程的其他线程取消，并调用pthread_exit（）退出. 这不是调用exit，因为线程会调用exit函数，这将导致线程所在的进程退出.

一个小例子:

启动两个线程，一个线程对全局变量num执行1加运算，执行500次，一个线程对全局变量执行1减运算，也执行500次.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
int num=0;
void *add(void *arg) {//线程执行函数，执行500次加法
  int i = 0,tmp;
  for (; i <500; i++)
  {
    tmp=num+1;
    num=tmp;
    printf("add+1,result is:%d\n",num);
  }
  return ((void *)0);
}
void *sub(void *arg)//线程执行函数，执行500次减法
{
  int i=0,tmp;
  for(;i<500;i++)
  {
    tmp=num-1;
    num=tmp;
    printf("sub-1,result is:%d\n",num);
  }
  return ((void *)0);
}
int main(int argc, char** argv) {
  
  pthread_t tid1,tid2;
  int err;
  void *tret;
  err=pthread_create(&tid1,NULL,add,NULL);//创建线程
  if(err!=0)
  {
    printf("pthread_create error:%s\n",strerror(err));
    exit(-1);
  }
  err=pthread_create(&tid2,NULL,sub,NULL);
  if(err!=0)
  {
    printf("pthread_create error:%s\n",strerror(err));
     exit(-1);
  }
  err=pthread_join(tid1,&tret);//阻塞等待线程id为tid1的线程，直到该线程退出
  if(err!=0)
  {
    printf("can not join with thread1:%s\n",strerror(err));
    exit(-1);
  }
  printf("thread 1 exit code %d\n",(int)tret);
  err=pthread_join(tid2,&tret);
  if(err!=0)
  {
    printf("can not join with thread1:%s\n",strerror(err));
    exit(-1);
  }
  printf("thread 2 exit code %d\n",(int)tret);
  return 0;
}

使用g ++编译文件（g ++ main.cpp -o main）. 此时，将报告对“ pthread_create”的未定义引用.

报告此错误的原因是: pthread库不是Linux的默认库，因此编译时需要指定libpthread.a库.

解决方案: 编译时添加-lpthread参数.

执行结果:

乍看之下，结果是正确的. 加500次并减去500次. 最终结果为0. 但是仔细查看所有输出，您会发现一些奇怪的东西.

产生这种不一致的原因是两个线程可以修改同一个变量. 如果线程1在执行tmp = 50 + 1之后被系统中断，则线程2在num = 50上执行减一运算，并且当线程1恢复时多线程编程，它将执行num = tmp = 51. 正确的结果应该是50. 因此，当多个线程修改共享区域时，应该同步它.

线程同步的五种三种方式:

1. 互斥对象互斥对象由pthread_mutex_t数据类型表示.

两种初始化方法，第一种: 分配常量PTHREAD_MUTEX_INITIALIZER；第二种，当互斥量被动态分配时，使用pthread_mutex_init函数进行初始化，使用pthread_mutex_destroy函数进行销毁.

#include<pthread.h>
int pthread_mutex_init (pthread_mutex_t *__mutex,
			    __const pthread_mutexattr_t *__mutexattr);
int pthread_mutex_destroy (pthread_mutex_t *__mutex);

返回值: 成功0，失败错误号以及解锁和锁定调用pthread_mutex_lock，解锁调用pthread_mutex_unlock.

#include<pthread.h>
int pthread_mutex_lock (pthread_mutex_t *__mutex)；
int pthread_mutex_unlock (pthread_mutex_t *__mutex)；

使用互斥锁修改以前的程序（修改的部分标记为红色）:

pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
void *add(void *arg) {
  int i = 0,tmp;
  for (; i <500; i++)
  {
    pthread_mutex_lock(&mylock);
    tmp=num+1;
    num=tmp;
    printf("+1,result is:%d\n",num);
    pthread_mutex_unlock(&mylock);
  }
  return ((void *)0);
}
void *sub(void *arg)
{
  int i=0,tmp;
  for(;i<500;i++)
  {
    pthread_mutex_lock(&mylock);
    tmp=num-1;
    num=tmp;
    printf("-1,result is:%d\n",num);
    pthread_mutex_unlock(&mylock);
  }
  return ((void *)0);
}

2. 读写锁定允许多个线程同时读取，并且只有一个线程可以同时写入. 它适用于阅读次数远大于写作次数的情况. 读写锁初始化:

#include<pthread.h>
int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
				__const pthread_rwlockattr_t *__restrict
				__attr);
int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);

返回值: 成功--0，失败错误编号

锁，这里分为读锁和写锁.

读取锁:

int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)

写入并锁定:

int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)

相同的解锁功能:

int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)

3. 条件变量条件变量由pthread_cond_t数据类型表示. 条件变量本身受互斥锁保护，因此在更改条件状态之前必须锁定互斥锁.

条件变量的初始化:

第一种，分配常量PTHREAD_COND_INITIALIZER;第二种，使用pthread_cond_init函数

int pthread_cond_init (pthread_cond_t *__restrict __cond,
   __const pthread_condattr_t *__restrict
   __cond_attr);int pthread_cond_destroy (pthread_cond_t *__cond);

有条件的等待

使用pthread_cond_wait等待条件成立.

 pthread_cond_wait (pthread_cond_t *__restrict __cond,
   pthread_mutex_t *__restrict __mutex)

此处应注意，通过调用pthread_cond_wait传递的互斥锁已锁定. pthread_cond_wait将调用线程放入等待条件线程列表中，然后释放互斥量. 当pthread_cond_wait返回时，互斥锁再次被锁定.

唤醒线程

pthread_cond_signal唤醒等待该条件的线程，而pthread_cond_broadcast唤醒等待该条件的所有线程.

int pthread_cond_signal (pthread_cond_t *__cond);
int pthread_cond_broadcast (pthread_cond_t *__cond)

一个示例，主线程启动4个线程，每个线程都有一个参数i（i =生成顺序），无论线程启动顺序如何，执行顺序只能是: 线程0，线程1，线程2，线程3.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#define DEBUG 1
int num=0;
pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready=PTHREAD_COND_INITIALIZER;
void * thread_func(void *arg)
{
  int i=(int)arg; 
  int ret;
  sleep(5-i);//线程睡眠,然最先生成的线程，最后苏醒
  pthread_mutex_lock(&mylock);//调用pthread_cond_wait前，必须获得互斥锁
  while(i!=num)
  {
#ifdef DEBUG
    printf("thread %d waiting\n",i);
#endif
    ret=pthread_cond_wait(&qready,&mylock);//该函数把线程放入等待条件的线程列表，然后对互斥锁进行解锁，这两部都是原子操作。并且在pthread_cond_wait返回时，互斥量再次锁住。
    if(ret==0)
    {
#ifdef DEBUG
      printf("thread %d wait success\n",i);
#endif
    }else
    {
#ifdef DEBUG
      printf("thread %d wait failed:%s\n",i,strerror(ret));
#endif
    }
  }
  printf("thread %d is running \n",i);
  num++;
  pthread_mutex_unlock(&mylock);//解锁
  pthread_cond_broadcast(&qready);//唤醒等待该条件的所有线程
  return (void *)0;
}
int main(int argc, char** argv) {
  
  int i=0,err;
  pthread_t tid[4];
  void *tret;
  for(;i<4;i++)
  {
    err=pthread_create(&tid[i],NULL,thread_func,(void *)i);
    if(err!=0)
    {
      printf("thread_create error:%s\n",strerror(err));
      exit(-1);
    }
  }
  for (i = 0; i < 4; i++)
  {
    err = pthread_join(tid[i], &tret);
    if (err != 0)
    {
      printf("can not join with thread %d:%s\n", i,strerror(err));
      exit(-1);
    }
  }
  return 0;
}

在非调试模式下，执行结果如下图所示:

在调试模式下，执行结果如下图所示:

可以看出，在DEBUG模式下，线程3首先被唤醒，然后执行pthread_cond_wait（输出线程3等待）. 此时多线程编程，在pthread_cond_wait中，互斥锁首先被解锁，然后进入等待状态. 这是线程2成功锁定互斥锁的过程，输入pthread_cond_wait（输出线程2等待），还解锁互斥锁，然后进入等待状态. 程0之前，全局变量与线程参数i一致，满足条件，未输入条件等待，并且线程0正在运行. 全局变量num执行增量操作，解锁互斥锁，然后唤醒所有等待该条件的线程. 唤醒线程3，并输出线程3等待成功. 但是，如果不满足条件，请再次执行pthread_cond_wait. 这样，将执行符合条件的线程，而不符合条件的线程将等待.

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/jisuanjixue/article-279722-1.html