线程

一、进程和线程的区别

1、什么是进程

进程：指在系统中能独立运行并作为资源分配的基本单位，它是由一组机器指令、数据和堆栈等组成的，是一个能独立运行的活动实体。简言之：进程就是正在运行中的程序。

2、进程的特征

• 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。
• 并发性：任何进程都可以同其他进程一起并发执行。
• 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。
• 异步性：由于进程间的互斥，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进。

3、什么是线程

    线程是轻量级的进程，是进程内部的一个控制序列，也就是一个程序里的一个执行路线，一个进程至少有一个线 程。

• 轻量级进程（light-weight process），也有PCB ，创建线程使用的底层函数和进程的一样，都是clone
• 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的
• 进程可以蜕变成线程线程可看成寄存器和栈的集合
• 在Linux下，线程是最小的执行单位，进程是最小的分配资源单位
• 在同一个进程中，不同的线程共享着进程中的资源（文件描述符、各种信号的处理方式、当前工作目录、用户ID和组ID
  内存地址空间）

4、进程和线程的区别

• 进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元
• 同一个进程中可以包括多个线程，并且线程共享整个进程的资源（寄存器、堆栈、上下文），一个进程至少包括一个线程
• 进程的创建调用fork或者vfork，而线程的创建调用pthread_create，进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束
• 线程是轻量级的进程，它的创建和销毁所需要的时间比进程小很多，所有操作系统中的执行功能都是创建线程去完成的
• 线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源
• 线程有自己的私有属性PCB，线程id，寄存器、硬件上下文，而进程也有自己的私有属性进程控制块PCB，这些私有属性是不被共享的，用来标识一个进程或一个线程的标志

二、线程的创建及使用

   1.创建新线程

     函数：int pthread_create(pthread_t *thread,      //线程id

                                     const pthread_attr_t *attr,  //NULL，线程属性

                                     void *(*start_routine) (void *),    //线程处理函数

                                       void *arg);     //参数

   代码：

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
void* route(void* arg)
{
    int i = *(int*)arg;
    free(arg);
    printf("%d 号线程创建成功\n",i);
}
int main()
{
    pthread_t tid[3];
    int i ;
    for(i = 0;i < 3;i++)
    {
        int *p = (int*)malloc(sizeof(int));
        *p = i + 1;
        pthread_create(&tid[i],NULL,route,p);
    }
    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);
    pthread_join(tid[2],NULL);
    return 0;
}

执行结果：

线程的常用函数还有：

//等待某线程结束 ---> wait

int pthread_join(pthread_t thread,        

                           void **retval);  //返回值

//结束一个线程  -----> exit(结束自己)

void pthread_exit( void *retval )

当一个进程有多个进程，只有当所有线程都结束时，进程才结束

//结束另外一个线程 ---->kill（杀死别人）

int pthread_cancel(pthread_t thread);  //返回值

void pthread_testcancel(void);  //设置cancel点 ：系统调用都是cancel点

不用回收线程，设置线程的属性：分离

pthread_detach(pthread_t threat); //设置分离状态

int pthread_attr_init(pthread_attr_t *attr); //初始化线程

int pthread_attr_destroy(pthread_attr_t *attr);

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);  

int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);

detachstate 的值:

PTHREAD_CREATE_DETACHED;

PTHREAD_CREATE_JOINABLE；

int pthread_attr_setstack(pthread_attr_t *attr,

                                 void *stackaddr, size_t stacksize);   //设置某个线程的栈空间大小

int pthread_attr_getstack(pthread_attr_t *attr,

                                 void **stackaddr, size_t *stacksize);

线程栈(每个线程都有独立的栈)之间有安全距离；

pthread_attr_setdetachstate() //设置属性（分离）

获得进程组的ID：signal（SIGCHLID,SIG_IGN）

获得线程的ID：      phtread_self()

比较两个线程是否相等：    pthread_equal();

当线程互斥的访问共享空间是的步骤：

互斥量：

 1.   pthread_mutex_t  mutex   

 2.   int pthread_mutex_init(pthread_mutex_t *restrict mutex,   //保证内存可见

              const pthread_mutexattr_t *restrict attr)；

 3.   int pthread_mutex_lock(pthread_mutex_t *mutex)   //   如果为0；阻塞    否则：置0 返回

       int pthread_mutex_unlock(pthread_mutex_t *mutex);       //置1，返回

 4.   int pthread_mutex_destroy(pthread_mutex_t *mutex);

条件变量：