linux 进程和线程 对比

线程和进程

这个概念不管在什么操作系统中都是一样的,也是面试官比较喜欢问的,代表你对程序优化的功底,搞安卓的时候,经常被用来优化处理速度 还有数据的处理,结合handler 一起处理,解决经常出现界面死掉问题。

既然总结了,这一次充分总结下:

进程

进程组成:

  1. 进程控制块PCB
  2. 程序段
  3. 数据段

进程控制块PCB 是内核中存放的一块PCB区域,记录型数据结构 ,PCB 记录了操作系统所需要的参数,用来描述进程目前情况和进程运行的全部信息,包括

  1. 进程描述信息:
    1. 进程标识符,识别进程
    2. 用户标识,用于资源共享和保护
    3. 家族关系,进程关于有父进程和子进程的信息
  2. 处理机状态信息:包含通用寄存器、指令寄存器、程序状态字(PSW)、用户栈指针等
    1. 进程状态 ,用作进程调度的依据
    2. 进程的优先级,处理机运行进程的依据
    3. 进程调度需要的数据: 比如已经等待CPU的总和、进程已经执行的时间总和
    4. 事件: 进程被阻塞的原因
  3. 进程控制信息
    1. 程序和数据的地址
    2. 进程和同步通信机制

进程的状态: 就绪、执行、阻塞

process

上面是进程的各种状态切换

当第一初始化进程的时候,进程进入就绪状态,等待OS 分配处理机处理进程,当进程获取处理机处理,进程执行阶段,执行的时候,一般会用来处理各种事物,比如 请求 IO 处理等,但是一旦有大量IO 处理,容易进入阻塞状态,此时就是我们经常看见电脑卡死的状态,但是处理完后,进程会进入就绪状态
其实还有一种状态,finish 结束状态,但是只要进程死了就直接退出了

线程

从上面很容易看出来,创建一个进程,因为直接和linux 内核进行处理数据,需要提供大量的参数,来保障进程的安全,高效,稳定,消耗很多系统资源,但是线程就不一样,可以原理是一样的,作为轻量级,消耗系统资源很少,而且作为开发者来说,线程用起来更爽,更方便,线程只能跑在进程中,所以,和系统内核交互的数据都交给进程了,线程简单方便易用,据说进程消耗资源是线程的30倍…..
线程和处理流程和 进程差不错 ,也是 就绪、执行、阻塞、结束四个状态

多线程编程的API

创建线程

int pthread_create(pthread_t *thread,pthread_attr_t *attr,void * (*func)(void * ),void *arg);
/*
看了上面的方法,mmp、wtf 这些词汇从我脑海中冒出来,函数参数要不要写的那么复杂
只能看调用示例了:
pthread(&thrd1,NULL,(void*)task1,(void*)&g1);
phtread thrd1 表示创建线程的标识
pthread_attr_t *attr 表示线程属性NULL 默认
void task1 线程需要执行的代码
int g1 表示task1的参数
*/

结束线程

pthread_exit(void *retval);
//retval 用来存放自杀线程退出状态

等待线程结束

// 多个线程启动后,由系统负责调度,但我们并不知道哪个会先开始和结束,只能等待
int pthread_join(pthread_t th,void **thread_return);
/*
th 等待线程的标识
thread_return 返回的状态
*/

多线程实例:

只有同步锁的情况,线程之间的同步互斥

用同步互斥原理,实现对变量shareid的操作

int shareid=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char const *argv[]) {
  pthread_t thrd1,thrd2;
  int ret;
  ret = pthread_create(&thrd1,NULL,(void *)task1,NULL);//创建线程
  ret = pthread_create(&thrd2,NULL,(void *)task2,NULL);
  pthread_join(thrd1,NULL);//等待线程结束
  pthread_join(thrd2,NULL);
  printf("shareid = %d\n",shareid );
  return 0;
}
  void task1(void) {
    long i,tmp;
    for ( i = 0; i < 10000; i++) {
      if (pthread_mutex_lock(&mutex)!=0) {//加同步锁
        perror("pthread_mutex_lock");
          exit(EXIT_FAILURE);
      }
      tmp = shareid;
      tmp = tmp+1;
      shareid = tmp;
      if (pthread_mutex_unlock(&mutex)!=0) {//解锁
        perror("pthread_mutex_unlock");
        exit(EXIT_FAILURE);
      }
    }
    printf("task1 finished shareid = %d\n" ,shareid);
  }
  void task2(void) {
    long i,tmp;
    for ( i = 0; i < 5000; i++) {
      if (pthread_mutex_lock(&mutex)!=0) {
        perror("pthread_mutex_lock");
          exit(EXIT_FAILURE);
      }
      tmp = shareid;
      tmp = tmp+1;
      shareid = tmp;
      if (pthread_mutex_unlock(&mutex)!=0) {
        perror("pthread_mutex_unlock");
        exit(EXIT_FAILURE);
      }
    }
    printf("task2 finished shareid = %d\n" ,shareid);
  }

因为 pthread 不是gcc 编译标准库,需要用到动态库加载,编译编译命令最后 加上-lpthread

gcc pthread_create.c -o pthread_create -lpthread

debug 结果:

ph_create

线程+同步锁+信号量 会有更有意思

很明显同步锁,有点死板,每次只能操作一个变量,不能实现多个公共资源的操作,但是加上信号量就有意思了

semaphore API 介绍

创建信号量

#include <semaphore.h>
int sem_init(sem_t *sem,int pshared,unsigned int value);
/*
功能: 初始化 信号量
返回值: 成功返回0 错误返回-1
sem: 指向信号量结构的指针
pshared 不为0 信号量在进程间共享,不然只能在本进程中的所有线程中共享
value 给出信号量的初始值
*/

信号量 P操作 -1

int sem_wait(sem_t *sem);

信号量 V操作 +1

int sem_post(sem_t *sem);

信号量删除

int sem_destroy(sem_t *sem);

看了上面的API,和进程中用的API 不一样? linux ipc 进程间通信总结
我只能这么理解了,进程和线程适用不同的信号量API

案例如下:

# define MAXSIZE 10

int stack[MAXSIZE][2];
int size = 0;
sem_t sem;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void provide_data(void){

  int i;
  for (i = 0; i < MAXSIZE; i++) {
    stack[i][0] = i;
    stack[i][1] = i;
    sem_post(&sem);// 信号量 V操作 +1
  }
}


void handle_data1(void) {
  int i;
  while (pthread_mutex_lock(&mutex),((i =size++)<MAXSIZE)) {
    pthread_mutex_unlock(&mutex);
    sem_wait(&sem);
    printf("Plus : %d + %d =%d \n",stack[i][0],stack[i][1],stack[i][0]+stack[i][1] );
  }
  pthread_mutex_unlock(&mutex);
}

void handle_data2(void) {
  int i;
  while (pthread_mutex_lock(&mutex),((i =size++)<MAXSIZE)) {
    pthread_mutex_unlock(&mutex);
    sem_wait(&sem);
    printf("Multiple : %d × %d =%d \n",stack[i][0],stack[i][1],stack[i][0]*stack[i][1] );
  }
  pthread_mutex_unlock(&mutex);
}

int main(int argc, char const *argv[]) {
  pthread_t thd1,thd2,thd3;
  sem_init(&sem,0,0);
  pthread_create(&thd1,NULL,(void *)handle_data1,NULL);
  pthread_create(&thd2,NULL,(void *)handle_data2,NULL);
  pthread_create(&thd3,NULL,(void *)provide_data,NULL);

  pthread_join(thd1,NULL);
  pthread_join(thd2,NULL);
  pthread_join(thd3,NULL);
  sem_destroy(&sem);
  return 0;
}

有一个线程th3对 stack 循环赋值,并且每赋值一次 将信号量sem V操作,thd1和thd2这两个线程会竞争获取stack 操作 thd1 是求和,而thd2是求商,哪一个线程获取资源了,求和或者求商,然后对sem进程P操作,所以每次运行程序会打印不同的结果
这里写图片描述
这里还有一个知识点, 逗号运算符

  while (pthread_mutex_lock(&mutex),((i =size++)<MAXSIZE)) {
    pthread_mutex_unlock(&mutex);
/*
 while 有两个表达式,最后只判断((i =size++) <MAXSIZE) 是否符合,前面只是对mutex 进行加锁操作,这样只是为了保证size 能正常执行++操作和判断
 */

逗号表达式: 逗号前面和后面的表达式都执行,但是只有最后一个返回值有效

其他unbelieve知识点

pthread_create 上面第二个参数一直设置NULL 系统默认属性,但是如果我们设置,该如何设置呢?

如果设置线程属性,必须在pthread_create 之前使用pthread_attr_init.

pthread_attr_t 结构体包含 是否绑定,是否分离,堆栈地址,堆栈大小,优先级信息

默认属性是 非绑定 非分离 默认1M大小堆栈 优先级和进程一样

轻进程概念,理解为内核进程,位于用户层和系统层之间,系统对线程资源的分配通过轻进程实现,如果设置绑定在轻进程,那个线程响应度高。

绑定状态

设置绑定状态的函数 pthread_attr_setscope

绑定:PTHREAD_SCOPE_SYSTEM 非绑定 PTHREAD_SCOPE_PROCESS

分离状态

线程的分离状态,用来决定如何结束自己
非分离状态使用pthread_join 处理,才能释放资源,分离状态的线程,运行结束,自动释放

非分离:PTHREAD_CREATE_JOINABLE 分离:PTHREAD_CREATE_DETACHED 设置参数的函数 pthread_attr_setdetachstate

如果设置线程分离状态,线程运行太快,在pthread_attr_init 之后,但是在pthread_create之前结束,那么此时创建线程,会得到错误线程号,需要避免,最简单的方法 执行pthread_cond_timewait 使得线程慢点跑

线程优先级

线程优先级 存放在结构体sched_param 用pthread_attr_getsparam 函数 和pthread_attr_setschedpara 存放, 先取得优先级,修改后,存放回去

线程创建后改变属性:

杀死其他线程的方法 pthread_cancel(thread)

但是线程可以设置属性 拒绝被杀死

pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL)
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL)

线程真的很不错的,优化用的特别多


阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/engineer_james/article/details/79963574
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭