线程和进程延续

1665916021

已于 2024-10-31 10:04:36 修改

阅读量968

点赞数 11

文章标签：开发语言 linux

于 2024-10-30 14:32:03 首次发布

本文链接：https://blog.youkuaiyun.com/m0_62995834/article/details/143323697

版权

1.线程和进程启动终止方式

1.创建子进程，子线程

2.退出进程/线程

3.回收僵尸进程资源 / 回收线程资源

4.进程终止函数 / 线程清理函数

2.线程状态切换

pthread_create()变为就绪态，调度后成为运行态，pthread_join()成为阻塞态，从运行态运行完或者异常退出后进入线程结束

3.线程属性初始化和销毁

最重要的是线程分离状态属性，其他系统会根据调度自己设置

使用线程属性前，需要初始化，结束再销毁

1.设置和获得分离属性

1.detach（分离）第一个函数是获得当前线程属性中的分离属性，第二个是设置线程的分离状态属性

2. detachstate取值为PTHREAD_CREATE_JOINABLE 要在主线程调用pthread_join()系统资源才会释放

3.以分离状态启动的线程，在线程结束后会自动释放占有的系统资源

4.线程启动分离属性编程实战

pthread_join(id, &)用于释放线程结束前相关资源

1.以正常状态启动需要调用pthread_join()

2.以分离状态启动线程不要调用pthread_join(),会出错，也不能利用这个函数获取子线程运行函数返回结果，分离的意思是主控线程于子线程分离开了

3.分离属性在网络通讯中使用的多，例如服务器要响应几百个客户端请求，启动很多个进程不合适，在服务器端启动多线程来处理服务器端的大并发客户端请求，来一个处理一个，处理完了自动释放资源。在服务器端如何如理客户端多并发处理请求，启动线程以分离状态启动，这是最优的方式

5.线程前章节回顾

6.线程同步和互斥

1.线程互斥

在全局变量使用，例如存款，一个线程存钱100万，还没存入被另外一个线程将存款金额修改为一万，这样导致存入只有一万，这样就涉及线程不安全，一个线程对共享资源操作时，其他线程就等待，其他线程按照系统优先级调度对共享资源进行访问和操作，这样是互斥的操作，线程的互斥，线程的执行是相互排斥的

利用以下技术达到线程互斥

2.线程同步

建立在线程互斥基础上，但也要考虑线程先后执行约束问题，后面线程必须等待前一个线程操作完毕，结果出来后，后面线程才能对这个结果进行操作

研发小组进行软件开发，测试小组对软件项目进行测试，类似两个线程，研发小组对软件开发好后，再对软件进行测试，这里包含线程互斥，包含线程相互执行的约束，等到研发小组对软件开发好后，测试小组再对共享资源进行操作，测试小组严重依赖与研发小组

3.线程互斥案例（银行ATM操作）

堆中

3.线程互斥锁（互斥量）

多个线程共享资源的场景使用，电话亭，进入电话亭打电话锁住（打完后开门其他人根据先后再进入）同一时刻只能有一个线程拿到该锁一个线程对共享资源加锁，其他线程视图上锁已经被锁的资源，将被挂起，直到拿到锁的线程解锁

互斥锁数据类型pthread_muxtex_t

互斥锁的创建和销毁

1.互斥锁初始化函数第二个参数，传入NULL,以默认的情况下创建默认互斥锁，是个标准互斥锁，所以一般情况下传入NULL就行

互斥锁上锁和解锁

pthread_mutex_lock()上锁，拿不到锁阻塞

pthread_mutex_trylock(),上锁，拿不到锁返回错误

对共享资源成功上锁到释放锁之间的区域叫做临界区

结构体中定义互斥锁与银行账户绑定

typedef struct{
    int code;  //账户账号
    double balance;

    //定义一把互斥锁
    //银行账户（共享资源），互斥锁

    /*
        建议互斥锁用来锁定一个账户，和账户绑定在一起，
        尽量不设置成全局变量，否则
        可能出现一把锁去锁几百个账户，导致并发性能降低
    */
    pthread_mutex_t mutex;
}Account;

account.h文件代码

#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__

#include <pthread.h>

typedef struct{
    int code;  //账户账号
    double balance;

    //定义一把互斥锁
    //银行账户（共享资源），互斥锁

    /*
        建议互斥锁用来锁定一个账户，和账户绑定在一起，
        尽量不设置成全局变量，否则
        可能出现一把锁去锁几百个账户，导致并发性能降低
    */
    pthread_mutex_t mutex;
}Account;

//创建账户
extern Account* create_account(int code, double balance);
//销毁账户
extern void destroy_account(Account *a);
//取款
extern double withdraw(Account *a, double amt);
//存款
extern double deposit(Account *a, double amt);
//查看账户余额
extern double get_balance(Account *a);


#endif

account.c代码


#include "account.h"
#include <malloc.h>
#include <assert.h>
#include <string.h>
#include <unistd.h>

//创建账户
Account* create_account(int code, double balance)
{
    //创建在堆中
    Account *a = (Account*)malloc(sizeof(Account));
    assert(a != NULL);  //()里面为bool类型，为假程序会就此结束
    a->code = code;
    a->balance = balance;

    //对互斥锁进行初始化
    pthread_mutex_init(&a->mutex, NULL);

    return a;
}
//销毁账户
void destroy_account(Account *a)
{
    assert(a != NULL);
    //销毁互斥锁
    pthread_mutex_destroy(&a->mutex);

    free(a);
}
//取钱
double withdraw(Account *a, double amt)
{
    assert(a != NULL);

    //从成功上锁到释放锁叫做临界区
    //加锁，对共享资源（账户）进行加锁,资源被占用则会阻塞
    pthread_mutex_lock(&a->mutex);

    if(amt < 0 || amt > a->balance){
        pthread_mutex_unlock(&a->mutex);
        return 0.0;
    }
    double balance = a->balance;

    //sleep(1)用来使这个线程延时让其他线程占用CPU取款，模拟情景
    sleep(1);  //取款操作有个过程，停顿一下，存取数据，读取数据

    balance -= amt;
    a->balance = balance; //银行账户余额

    //释放互斥锁
    pthread_mutex_unlock(&a->mutex);
    return amt; //取款成功返回取款金额
}
//存钱
double deposit(Account *a, double amt)
{
    assert(a != NULL);
    
    //上锁
    pthread_mutex_lock(&a->mutex);
    if(amt < 0){
        //解锁
        pthread_mutex_unlock(&a->mutex);
        return 0.0;
    }
    a->balance += amt;
    sleep(1);

    //解锁
    pthread_mutex_unlock(&a->mutex);
    
    return amt;
}
//查看账户余额
double get_balance(Account *a)
{
    assert(a != NULL);

    //上锁
    pthread_mutex_lock(&a->mutex);

     //解锁
    pthread_mutex_unlock(&a->mutex);

    return (a->balance);
}

account_test.c代码

#include "account.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

typedef struct{
    char name[20];   //名字
    Account *account;  //账户
    double amt;   //存取款金额
}OperArg;   //操作参数


//定义取款操作的线程运行函数
void*   withdraw_fn(void *arg)
{
    OperArg *oa = (OperArg*)arg;
    //取钱的账户和金额，取款失败返回0
    double amt = withdraw(oa->account, oa->amt);
    printf("%s(0x%lx) withdraw %f from account %d\n",
        oa->name, pthread_self(),
         amt, 
        oa->account->code);

    return (void*)0;
}

//定义存款操作的线程运行函数
void*   deposit_fn(void *arg)
{
    OperArg *oa = (OperArg*)arg;
    //存钱的账户和金额
    double amt = deposit(oa->account, oa->amt);
    printf("%s(0x%lx) withdraw %f from account %d\n",
        oa->name, pthread_self(),
         amt, 
        oa->account->code);

    return (void*)0;

}

//定义检查银行账户的线程运行函数
void*   check_fn(void *arg)
{
    OperArg* oa = (OperArg*)arg;

    double balance;
    balance = get_balance(oa->account);
    printf("balance %f", balance);

    return (void*)0;
}

int main(void)
{
    int err;
    pthread_t boy, girl;
    //第一个是账户编码号，第二个是余额
    //这里两个线程的账户都初始化为a
    Account *a = create_account(100001, 10000); 

    OperArg o1, o2;  //传入不同线程运行函数中
    strcpy(o1.name, "boy");
    o1.account = a;  
    o1.amt = 10000;


    strcpy(o2.name, "girl");
    o2.account = a;
    o2.amt = 10000;

    //启动两个子线程(boy 和girl线程)
    //同时去操作同一个银行账户
    if((err = pthread_create(&boy, NULL, withdraw_fn, (void*)&o1)) != 0)
    {
        perror("pthread create error");
    }
    if((err = pthread_create(&girl, NULL, withdraw_fn, (void*)&o2)) != 0)
    {
        perror("pthread create error");
    }
    pthread_join(boy, NULL);
    pthread_join(girl, NULL);

    //
    printf("account balance: %f\n", get_balance(a));
    destroy_account(a); //销毁账户


    return 0;
}

gcc运行编译结果

ji@ji-VM:~/c/pthread/account$ gcc account.c account_test.c 
ji@ji-VM:~/c/pthread/account$ ./a.out 
boy(0x7a8183200640) withdraw 10000.000000 from account 100001
girl(0x7a8182800640) withdraw 0.000000 from account 100001
account balance: 0.000000
ji@ji-VM:~/c/pthread/account$

4.互斥锁属性创建和销毁

互斥锁属性创建传入NULL则是创建标准互斥锁

5.设置和获取互斥锁进程共享属性

7.互斥锁类型操作

互斥锁初始化的时候

lockattr.c的代码，验证多次上锁同一互斥锁时，各种互斥锁属性对应的反应

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

int main(int argc,  char *argv[])
{
    //定义互斥锁
    pthread_mutex_t mutex;

    if(argc < 2){
        printf("-usage:%s [error|normal|recursive]\n",
            argv[0]);
        exit(1);
    }

    //定义互斥锁属性
    pthread_mutexattr_t mutexattr;
    //初始化互斥锁属性
    pthread_mutexattr_init(&mutexattr);

    //字符串比较函数strcmp(),字符串相等返回0
    if(!strcmp(argv[1], "error")){
        //设置互斥锁类型,为检错互斥锁
        pthread_mutexattr_settype(&mutexattr,
            PTHREAD_MUTEX_ERRORCHECK);
    }else if(!strcmp(argv[1], "normal")){
        //设置标准互斥锁
        pthread_mutexattr_settype(&mutexattr,
            PTHREAD_MUTEX_NORMAL);
    }else if(!strcmp(argv[1], "recursive")){
        //设置递归互斥锁
        pthread_mutexattr_settype(&mutexattr,
            PTHREAD_MUTEX_RECURSIVE);
    }

    //初始化互斥锁
    pthread_mutex_init(&mutex, &mutexattr);

    //上锁
    if(pthread_mutex_lock(&mutex) != 0){
        printf("lock failure\n");
    }else{
        printf("lock success\n");
    }

    //上锁第二次，用于模拟第二次
    //上锁面对不同互斥锁属性
    if(pthread_mutex_lock(&mutex) != 0){
        printf("lock failure\n");
    }else{
        printf("lock success\n");
    }

    //释放锁
    pthread_mutex_unlock(&mutex);
    
    return 0;
}

运行结果，正常锁第二次调用会阻塞，

8.线程互斥——读写锁

1.线程使用互斥锁缺乏读并发性

2.读写锁创建和销毁

3.读写锁加锁和解锁

pthread_rwlock_rdlock() //加读锁

pthread_rwlock_wrlock（）//加写锁

rwlock.c上读锁，写锁多次案例

1.读和读不排斥；

2.写和写排斥；

3.读和写排斥；

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

//定义读写锁
pthread_rwlock_t rwlock;

int main(int argc, char *argv[])
{
    if(argc < 3){
        printf("-usage:%s [r|w] [r|w]\n", argv[0]);
        exit(1);
    }

    //读写锁初始化
    pthread_rwlock_init(&rwlock, NULL);

    if(!strcmp(argv[1], "r")){
        //加读锁
        if(pthread_rwlock_rdlock(&rwlock) != 0){
            printf("first read lock failure\n");
        }else{
            printf("first read lock success\n");
        }
    }else if(!strcmp(argv[1], "w")){
        //加写锁
        if(pthread_rwlock_wrlock(&rwlock) != 0){
            printf("first write lock failure\n");
        }else{
            printf("first write lock success\n");
        }
    }

    if(!strcmp(argv[2], "r")){
        //加读锁
        if(pthread_rwlock_rdlock(&rwlock) != 0){
            printf("second read lock failure\n");
        }else{
            printf("second read lock success\n");
        }
    }else if(!strcmp(argv[2], "w")){
        //加写锁
        if(pthread_rwlock_wrlock(&rwlock) != 0){
            printf("second write lock failure\n");
        }else{
            printf("second write lock success\n");
        }
    }

    //解锁，释放读写锁
    pthread_rwlock_unlock(&rwlock);
    pthread_rwlock_unlock(&rwlock);

    //摧毁读写锁
    pthread_rwlock_destroy(&rwlock);

    return 0;
}

用读写锁解决银行取钱和存钱和查看余额之间的互斥利害