嵌入式开发学习--进程、线程

什么是进程

进程和程序的区别

概念
程序：编译好的可执行文件，存放在磁盘上的指令和数据的有序集合（文件），程序是静态的，没有任何执行的概念。
进程：一个独立的可调度的任务，执行一个程序所分配的资源的总称，进程是程序的一次执行过程，进程是动态的，包括创建、调度、执行和消亡。

进程特点
(1)系统会为每个进程分配0-4g的虚拟空间，0-3g(用户空间)是每个进程所独有的，3g-4g（内核空间）是所有进程所共有的。

(2)CPU调度进程时会给进程分配时间片(几毫秒~十几毫秒)，时间片用完后，cpu再进行其他进程的调度，实现进程的轮转，从而实现多任务的操作。(没有外界干预的情况下怎么调度进程是CPU随机分配的 )。
进程段
Linux中的进程大致包含三个段：
数据段：存放的是全局变量、常数以及动态数据分配的数据空间(如malloc函数取得的空间)等。
正文段：存放的是程序中的代码
堆栈段：存放的是函数的返回地址、函数的参数以及程序中的局部变量 （类比内存的栈区）。
进程分类
**交互进程：**该类进程是由shell控制和运行的。交互进程既可以在前台运行，也可以在后台运行。该类进程经常与用户进行交互，需要等待用户的输入，当接收到用户的输入后，该类进程会立刻响应，典型的交互式进程有：shell命令进程、文本编辑器等
**批处理进程：**该类进程不属于某个终端，它被提交到一个队列中以便顺序执行。(目前接触不到)
**守护进程：**该类进程在后台运行。它一般在Linux启动时开始执行，系统关闭时才结束。

进程状态

D uninterruptible sleep (usually IO) 不可中断的睡眠态
R running or runnable (on run queue) 运行态
S interruptible sleep (waiting for an event to complete) 可中断的睡眠态
T stopped by job control signal 暂停态
t stopped by debugger during the tracing 因为调试而暂停
X dead (should never be seen) 死亡态
Z defunct (“zombie”) process, terminated but not reaped by its parent 僵尸态
< high-priority (not nice to other users) 高优先级
N low-priority (nice to other users) 低优先级
L has pages locked into memory (for real-time and custom IO) 锁在内存中
s is a session leader 会话组组长
l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)多线程
+ is in the foreground process group 前台进程
进程切换图

进程创建后，进程进入就绪态，当CPU调度到此进程时进入运行态，当时间片用完时，此进程会进入就绪态，如果此进程正在执行一些IO操作(阻塞操作)会进入阻塞态，完成IO操作（阻塞结束）后又可进入就绪态，等待CPU的调度，当进程运行结束即进入结束态。

进程相关命令
ps 查看系统中运行的进程-aux -ef
top 动态显示系统中运行的进程
renice 改变正在运行的进程的优先级
nice 按用户指定的优先级运行进程
kill 给进程发信号
bg 将进程切换到后台
fg 将进程切换到前台
jobs 查看当前终端的进程

进程函数接口

创建进程fork()

pid_t fork(void);
功能：创建子进程
返回值：
    成功：在父进程中：返回子进程的进程号 >0
         在子进程中：返回值为0
    失败：-1并设置errno
1
2
3
4
5
6

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

int main(int argc, char const *argv[])
{
    pid_t pid = fork(); //创建一个子进程

    if(pid<0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid==0)  //子进程
    {
        printf("i am child\n");
        while(1);  //让子进程不要结束
    }
    else    //父进程
    {
        printf("i am parent\n");
        while(1);  //让父进程不要结束
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

执行：./a.out

特点：
1）子进程几乎拷贝了父进程的全部内容。包括代码、数据、系统数据段中的pc值、栈中的数据、父进程中打开的文件等；但它们的PID、PPID是不同的。
2）父子进程有独立的地址空间，互不影响；当在相应的进程中改变全局变量、静态变量，都互不影响。
3）若父进程先结束，子进程成为孤儿进程，被init进程收养，子进程变成后台进程。
4）若是子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程（要避免僵尸进程的产生）。
回收资源

pid_t wait(int *status);
功能：回收子进程资源(阻塞)
参数：status：子进程退出状态，不接受子进程状态设为NULL
返回值：成功：回收的子进程的进程号
              失败：-1

pid_t waitpid(pid_t pid, int *status, int options);
功能：回收子进程资源
参数：
    pid：>0     指定子进程进程号
         =-1   任意子进程
         =0    等待其组ID等于调用进程的组ID的任一子进程
         <-1   等待其组ID等于pid的绝对值的任一子进程
    status：子进程退出状态，不接受子进程状态设为NULL
    options：0：阻塞 WNOHANG：非阻塞
返回值：正常：结束的子进程的进程号
      当使用选项WNOHANG且没有子进程结束时：0
      出错：-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char const *argv[])
{
    pid_t pid = fork(); //创建一个子进程

    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) //子进程
    {
        printf("i am child\n");
        sleep(3);
    }
    else //父进程
    {
        printf("i am parent\n");
        //wait(NULL);
        //waitpid(-1,NULL,0); //此时和wait(NULL)一样，0代表阻塞。
        //waitpid(-1,NULL,WNOHANG);  //WNOHANG代表非阻塞，此时有可能接收不到子进程资源从而产生僵尸

        while (1) //所以用WNOHANG的时候需要通过循环调用
        {
            if (waitpid(-1, NULL, WNOHANG) > 0) //直到接收到了子进程资源就结束
                break;
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

结束进程

void exit(int status);
功能：结束进程，刷新缓存

void _exit(int status);
功能：结束进程，不刷新缓存

参数数：status是一个整型的参数，可以利用这个参数传递进程结束时的状态。
通常0表示正常结束；
其他的数值表示出现了错误，进程非正常结束
1
2
3
4
5
6
7
8
9

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

int main(int argc, char const *argv[])
{
    printf("hello");
    //exit(0);   //结束进程，刷新缓存
    _exit(0);    //结束进程，不刷新缓存
    while (1);

    //思考：exit和return的区别？
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

eixt结束的是当前整个进程，return结束的是当前函数。
获取进程号

pid_t getpid(void);
功能：获取当前进程的进程号
pid_t getppid(void);
功能：获取当前进程的父进程号
1
2
3
4

exec函数族(了解)

在一个进程中执行另一个进程：
system(“clear”);
system(“ls -l”);
system函数所启动进程不会替换原本进程，但是exec函数族所启动进程会替换原本进程。
守护进程 Daemon
Linux以会话(session)、进程组的方式管理进程，每个进程属于一个进程组，也就是多个进程组成一个进程组。会话是一个或多个进程组的集合，通常用户打开一个终端时，系统会创建一个会话。所有通过该终端运行的进程都属于这个会话。终端关闭时，所有相关进程会被结束。但是守护进程却能突破这种限制，不受终端关闭的影响。
守护进程特点
守护进程是后台进程;
生命周期比较长，从系统开启时开启，系统关闭时结束;它是脱离控制终端且周期执行的进程。
创建步骤
1） 创建子进程，父进程退出
让子进程变成孤儿进程，成为后台进程；fork()
2） 在子进程中创建新会话
让子进程成为会话组组长并且脱离终端：为了让子进程完全脱离终端；setsid()
3） 改变进程运行路径为根目录
原因: 进程运行的路径不能被删除或卸载；chdir(“/”)
函数说明：chdir() 将进程当前的工作目录改变成以参数路径所指的目录
4） 重设文件权限掩码
目的：增大进程创建文件时权限，提高灵活性；umask(0)
子进程继承了父进程的文件权限掩码，给该子进程使用文件带来一定的影响，因此把文件 权限掩码设置为0，可以增强该守护进程的灵活性。
5） 关闭文件描述符
原因：子进程继承了父进程的一些已经打开了的文件，这些被打开的文件可能永远不会被 守护进程访问，但它们一样占用系统资源，而且还可能导致所在的文件系统无法被卸载。
将不需要的文件关闭：close()

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if(pid<0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        setsid();
        chdir("/");
        umask(0);
        for(int i=0;i<3;i++)  //关闭默认打开的文件描述符0 1 2 
            close(i);
        while(1);
    }
    else
    {
        exit(0);
    }
     
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

线程

什么是线程

概念
线程是一个轻量级的进程，为了提高系统的性能引入线程。
线程和进程都参与统一的调度。
在同一个进程中可以创建的多个线程, 共享进程资源。
（Linux里同样用task_struct来描述一个线程）
进程和线程的区别
相同点：都为操作系统提供了并发执行能力
不同点：
调度和资源：线程是系统调度的最小单位，进程是资源分配的最小单位
地址空间方面：同一个进程创建的多个线程共享该进程的资源；进程的地址空间相互独立
通信方面：线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；进程通信比较复杂，需要借助进程间的通信机制(借助3g-4g内核空间)
安全性方面：线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全
线程资源
共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID
私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈(局部变量, 返回地址)、错误号 (errno)、信号掩码和优先级、执行状态和属性
练习: 通过父子进程完成对文件的拷贝(cp)

函数接口

创建线程：pthread_create

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                                void *(*start_routine) (void *), void *arg);
功能：创建线程
参数：       thread：线程标识
            attr：线程属性， NULL：代表设置默认属性
            start_routine：函数名：代表线程函数（自己写的）
            arg：用来给前面函数传参
返回值：成功：0
      失败：错误码
      
编译的时候需要加 -pthread 链接动态库
1
2
3
4
5
6
7
8
9
10
11

创建线程

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

//线程函数
void *handler_thread(void *arg)
{
    printf("in handler_thread\n");
    while (1)
        ; //让从线程不退出，进程状态l也就是多线程
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
    {
        perror("create thread err");
        return -1;
    }
    printf("in main\n");
    while (1)
        ; //不能让整个进程结束
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

退出线程：pthread_exit

void  pthread_exit(void *value_ptr) 
功能：用于退出线程的执行
参数：value_ptr：线程退出时返回的值
1
2
3

回收线程资源

int  pthread_join(pthread_t thread,  void **value_ptr) 
功能：用于等待一个指定的线程结束，阻塞函数
参数：thread：创建的线程对象,线程ID
     value_ptr：指针*value_ptr指向线程返回的参数， 一般为NULL
返回值：成功 ： 0
       失败：errno

int pthread_detach(pthread_t thread);
功能：让线程结束时自动回收线程资源,让线程和主线程分离,非阻塞函数
参数：thread：线程ID
非阻塞式的，例如主线程分离(detach)了线程T2，那么主线程不会阻塞在pthread_detach()，pthread_detach()会直接返回，线程T2终止后会被操作系统自动回收资源。
1
2
3
4
5
6
7
8
9
10
11

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

//线程函数
void *handler_thread(void *arg)
{
    printf("in handler_thread\n");
    pthread_exit(NULL); //让从线程退出
    while (1)
        ;
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
    {
        perror("create thread err");
        return -1;
    }
    printf("in main\n");

    //回收指定线程资源
    //pthread_join(tid,NULL);
    pthread_detach(tid);

    while (1)
        ; //不能让整个进程结束

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

同步

概念
同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情
(异步：异步则反之，并非一定需要一件事做完再做另一件事。）
同步机制
通过信号量实现线程间同步。
信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待.
信号量代表某一类资源，其值表示系统中该资源的数量:
信号量的值>0,表示有资源可以用, 可以申请到资源,
信号量的值<=0, 表示没有资源可以通用, 无法申请到资源, 阻塞.
信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)

sem_init: 信号量初始化
sem_wait: 申请资源,P操作, 如果没有资源可以用, 阻塞,-1
sem_post: 释放资源,V操作, 非阻塞 +1
1
2
3

函数接口

int  sem_init(sem_t *sem,  int pshared,  unsigned int value)  
功能：初始化信号量   
参数：sem：初始化的信号量对象
    pshared：信号量共享的范围(0: 线程间使用   非0:1进程间使用)
    value：信号量初值
返回值：成功 0
       失败 -1

int  sem_wait(sem_t *sem)  
功能：申请资源  P操作 
参数：sem：信号量对象
返回值：成功 0
       失败 -1
注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞
       
int  sem_post(sem_t *sem)   
功能：释放资源  V操作      
参数：sem：信号量对象
返回值：成功 0
      失败 -1
注：释放一次信号量的值加1，函数不阻塞
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

sem_t sem;
char buf[32];

void *handler_thread(void *arg)
{
    while (1)
    {
        //申请资源
        sem_wait(&sem);
        if (strcmp(buf, "quit") == 0)
            break;
        printf("%s\n", buf);
    }
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
    {
        perror("pthread create err");
        return -1;
    }

    //初始化信号量
    if (sem_init(&sem, 0, 0) != 0)
    {
        perror("sem init err");
        return -1;
    }

    while (1)
    {
        
        scanf("%s", buf);
        //释放资源
        sem_post(&sem);
        if (strcmp(buf, "quit") == 0)
            break;
    }

    pthread_join(tid, NULL);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

互斥

概念
互斥：多个线程在访问临界资源时，同一时间只能一个线程访问
临界资源：一次仅允许一个线所使用的资源
临界区：指的是一个访问共享资源的程序片段
互斥锁：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。

pthread_mutex_init
pthread_mutex_lock
pthread_mutex_unlock
1
2
3

函数接口

int  pthread_mutex_init(pthread_mutex_t  *mutex, pthread_mutexattr_t *attr)  
功能：初始化互斥锁  
参数：mutex：互斥锁
    attr:  互斥锁属性  //  NULL表示缺省属性
返回值：成功 0
      失败 -1

int  pthread_mutex_lock(pthread_mutex_t *mutex)   
功能：申请互斥锁     
参数：mutex：互斥锁
返回值：成功 0
      失败 -1
注：和pthread_mutex_trylock区别：pthread_mutex_lock是阻塞的；pthread_mutex_trylock不阻塞，如果申请不到锁会立刻返回

int  pthread_mutex_unlock(pthread_mutex_t *mutex)   
功能：释放互斥锁     
参数：mutex：互斥锁
返回值：成功 0
      失败 -1

int  pthread_mutex_destroy(pthread_mutex_t  *mutex)  
功能：销毁互斥锁     
参数：mutex：互斥锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;

void *handler_print(void *arg)
{
    while (1)
    {
        pthread_mutex_lock(&lock);
        for (int i = 0; i < 10; i++)
            printf("%d ", a[i]);
        printf("\n");
        pthread_mutex_unlock(&lock);
        sleep(1);
    }
    return NULL;
}

void *handler_swap(void *arg)
{
    int t;
    while (1)
    {
        pthread_mutex_lock(&lock);
        for (int i = 0; i < 5; i++)
        {
            t = a[i];
            a[i] = a[9 - i];
            a[9 - i] = t;
        }
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid1;
    if (pthread_create(&tid1, NULL, handler_print, NULL) != 0)
    {
        perror("pthread print create err");
        return -1;
    }

    pthread_t tid2;
    if (pthread_create(&tid2, NULL, handler_swap, NULL) != 0)
    {
        perror("pthread swap create err");
        return -1;
    }

    //初始化互斥锁
    if (pthread_mutex_init(&lock, NULL) != 0)
    {
        perror("init err");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    pthread_mutex_destroy(&lock);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

死锁
是指两个或两个以上的进程或线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。
死锁产生的四个必要条件
1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

条件变量

条件变量用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。

一般和互斥锁搭配使用，实现同步机制:
pthread_cond_init(&cond,NULL); //初始化条件变量

使用前需要上锁：
pthread_mutex_lock(&lock); //上锁
判断条件
pthread_cond_wait(&cond, &lock); //阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁

pthread_cond_signal(&cond); //产生条件，不阻塞

pthread_cond_destroy(&cond); //销毁条件变量

注意： 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件