Linux学习笔记-多线程（linux多线程原理）

1，线程和进程的区别：

线程是CPU调度和分派的基本单位，它可以和同一进程下的其他线程共享全部资源，进程是程序的一次执行过程，是程序在执行过程中的分配和管理资源的基本单位，每个进程都有自己的地址空间。线程是进程中的一部分，一个进程可以有多个线程，但线程只能存在于一个进程中。

根本区别：进程是操作系统资源调度的基本单位，线程是任务的调度执行的基本单位。

开销方面：进程都有自己的独立数据空间，程序之间的切换开销大；线程也有自己的运行栈和程序计数器，线程间的切换开销较小。

共享空间：进程拥有各自独立的地址空间、资源，所以共享复杂，需要用IPC（Inter-Process Communication，进程间通信），但是同步简单。而线程共享所属进程的资源，因此共享简单，但是同步复杂，需要用加锁等措施。

2，进程的创建函数：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr，
                   void *(*start_routine) (void *),  void *arg);

函数解释：

		//创建一个进程，成功返回0,失败返回错误号
    //参数1：存储创建的线程的线程号，自己定义
    //参数2：创建线程的参数，填NULL时按默认属性创建
    //参数3：新线程开始执行的函数的指针
    //参数4：参数3函数的参数
   例子： int ret=pthread_create(&thread,NULL,start_routine,NULL);

3，进程的退出或取消：

void pthread_exit(void *retval);
int pthread_cancel(pthread_t thread);

pthread_exit函数用来终止调用线程，并通过retval返回一个值；

pthread_cancel函数用来取消一个正在执行的线程，前提是线程被设置为可取消状态可以通过以下函数来设置线程的状态：

  int pthread_setcancelstate(int state, int *oldstate);
  int pthread_setcanceltype(int type, int *oldtype);

对应的状态参数有：

PTHREAD_CANCEL_ENABLE
PTHREAD_CANCEL_DISABLE
上边两个对应state参数;代表可取消还是不可取消
PTHREAD_CANCEL_DEFERRED
PTHREAD_CANCEL_ASYNCHRONOUS
对应type参数表示线程取消类型：延迟到下一个请求取消和立刻取消

线程退出时执行的顺序

1,清理处理程序弹出

2,调用线程特定的数据析构函数(pthread_cleanup_push类似于atexit()函数)

3,线程终止

4，线程的等待函数：

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

具有阻塞性质的等待指定线程号结束，并且retval会接受线程结束的返回值，配合上边的exit函数。对应线程不执行完毕，程序不会继续执行。

5，线程的清理函数：

线程可以安排异常退出时需要调用的函数，这样的函数称为线程清理程序，线程可以建立多个清理程序。线程清理程序的入口地址使用栈保存，实行先进后处理原则。pthread_cancel或pthread_exit引起的线程结束，会次序执行由pthread_cleanup_push压入的函数。线程函数执行return语句返回不会引起线程清理程序被执行。

void pthread_cleanup_push(void (*routine)(void *),void *arg);
void pthread_cleanup_pop(int execute);

6，线程的状态函数：

线程状态

1，非绑定：默认状况下，启动多少轻进程、哪些轻进程来控制哪些线程是由系统来控制的，这种状况即称为非绑定的

2，绑定状态：程固定的"绑"在一个轻进程之上。被绑定的线程具有较高的响应速度

3，非分离状态：线程的默认属性是非分离状态，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源

4，分离状态：分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。

分离状态设置：

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
PTHREAD_CREATE_DETACHED：分离状态
PTHREAD_CREATE_JOINABLE：非分离状态

绑定属性：

int pthread_attr_setscope(pthread_attr_t *attr, int scope);
int pthread_attr_getscope(const pthread_attr_t *attr, int *scope);
PTHREAD_SCOPE_SYSTEM：非绑定
PTHREAD_SCOPE_PROCESS：绑定与线程中

线程创建的案例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <error.h>
#include <errno.h>
#define handle_error_en(en, msg) do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
int *p=NULL;
void routine(void *arg)//线程清理函数
{
  int *pp=(int *)arg;
  free(pp);
  printf("this is routine free\n");
}
void *start_routine (void *arg)//创建的线程
{
  int execute=0;
  int num=*(int *)arg;
  int i=0,state=PTHREAD_CANCEL_ENABLE,oldstate=0;
  int type=PTHREAD_CANCEL_ASYNCHRONOUS,oldtype=0;
  static int retval=1;
  //pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
  //pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
  p=(int *)malloc(sizeof(int));//清理函数释放的空间
  pthread_cleanup_push(routine,(void *)p);//清理函数
  for(i=0;i<=num;i++)
  {
      printf("this is my first thread:%lu\n",pthread_self());
      sleep(1);
  }
  free(p);
  printf("this is thread free\n");
  pthread_cleanup_pop(execute);//配合push函数，类似于一对大括号{}
  pthread_exit(&retval);//退出返回retaval
}
int main(int argc, char const* argv[])
{
  int count=5,i=0;
  pthread_t thread;
  void *retval=NULL;
  int ret=pthread_create(&thread,NULL,start_routine,(void *)&count);//创建线程
  if(ret==-1)
  {
    handle_error_en(ret,"pthread_create");
  }
  for(i=0;i<=count;i++)
  {
    printf("this is main thread:%lu\n",thread);
    if(i==2)
      pthread_cancel(thread);
    sleep(1);
  }
  pthread_join(thread,&retval);//等带进程结束
  printf("%d\n",*(int *)(retval));
  return 0;
}