Linux线程相关复习

已于 2024-02-28 14:43:42 修改
阅读量890 收藏 6
点赞数 24
分类专栏： Linux 文章标签： linux
于 2024-01-29 11:20:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu___l/article/details/135890682
版权

线程基本操作 

创建线程

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

void * thread_jobs(void * arg)
{
        //普通线程任务区
        printf("thread tid %x\n",(unsigned int)pthread_self());
        while(1)
                sleep(1);
}

int main(void)
{
        //主线程任务区
        pthread_t tid;
        int err;
        if((err = pthread_create(&tid,NULL,thread_jobs,NULL))>0){
                printf(" failed : %s\n",strerror(err));
                exit(0);  // err > 0 线程创建失败 退出进程

        }
        printf("主线程的pid：%x\n被创建出来的线程的pid：%x\n",(unsigned int)pthread_self(),(unsigned int)tid);

        //防止主线程过早退出，看不到普通线程效果
        while(1)
                sleep(1);
        return 0;
}

main函数里面执行的代码是主线程，jobs里是普通线程

create传出的tid，与普通线程里面的tid相同，但不是一个，只有pthread_self()里面出来的tid才代表该线程还活着

join阻塞回收


#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/fcntl.h>
#include<pthread.h>
#include<signal.h>

void * thread_jobs(void * arg)
{
        //普通线程任务区
        int flag = 5;
        while(flag--){
                printf("thread tid %x\n",(unsigned int)pthread_self());
                sleep(1);
        }
        pthread_exit((void*)6);
}

int main(void)
{
        //主线程任务区
        pthread_t tid;
        int err;
        if((err = pthread_create(&tid,NULL,thread_jobs,NULL))>0){
                printf(" failed : %s\n",strerror(err));
                exit(0);  //退出进程

        }
        printf("主线程的pid：%x\n被创建出来的线程的pid：%x\n",(unsigned int)pthread_self(),(unsigned int)tid);

        //等待线程执行
        void * reval = NULL;
        if((err=pthread_join(tid,&reval))==0){
                printf("Master thread join success , thread reval %ld\n",(long int)reval);
        }
        while(1)
                sleep(1);
        return 0;
}

等待线程执行五秒后再回收。 

 cancel杀死线程

不等普通线程运行完，三秒之后直接杀死普通线程，返回值-1

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

void * thread_jobs(void * arg)
{
        //普通线程任务区
        int flag = 5;
        while(flag--){
                printf("thread tid %x\n",(unsigned int)pthread_self());
                sleep(1);
        }
        pthread_exit((void*)6);
}

int main(void)
{
        //主线程任务区
        pthread_t tid;
        int err;
        if((err = pthread_create(&tid,NULL,thread_jobs,NULL))>0){
                printf(" failed : %s\n",strerror(err));
                exit(0);  //退出进程

        }
        printf("主线程的pid：%x\n被创建出来的线程的pid：%x\n",(unsigned int)pthread_self(),(unsigned int)tid);

        //等待线程执行
        void * reval = NULL;
        sleep(3);
        pthread_cancel(tid);

        if((err=pthread_join(tid,&reval))==0){
                printf("Master thread join success , thread reval %ld\n",(long int)reval);
        }
        while(1)
                sleep(1);
        return 0;
}

detach设置线程分离态

 这段代码不知道为什么始终都走不到回收失败那段。。。

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

void * thread_jobs(void * arg)
{
        //普通线程任务区
        int flag = 5;
        pthread_detach(pthread_self());
        while(1){
        }

        pthread_exit((void*)6);
}

int main(void)
{
        //主线程任务区
        pthread_t tid;
        int err;
        if((err = pthread_create(&tid,NULL,thread_jobs,NULL))>0){
                printf(" failed : %s\n",strerror(err));
                exit(0);  //退出进程

        }
        printf("主线程的pid：%x\n被创建出来的线程的pid：%x\n",(unsigned int)pthread_self(),(unsigned int)tid);

        //等待线程执行
        void * reval = NULL;
        if((err=pthread_join(tid,&reval))==0){
                printf("Master thread join success , thread reval %ld\n",(long int)reval);
        }else{
                printf("join failed : %s\n",strerror(err));
        }
        while(1)
                sleep(1);
        return 0;
}
~

定义线程属性并修改

pthread_create的第二个参数就是线程属性，传入NULL代表默认系统给出的线程属性

线程属性是一个结构体，用法为 pthread_attr_t 变量名

线程属性结构体中的成员分别有：线程的警戒缓冲区、线程的优先级指针、线程的退出状态、线程栈地址、线程栈大小

步骤：

        1.定义线程属性

        2.初始属性（默认）

        3.修改属性

        4.创建线程并使用自定义属性 pthread(&tid,&attr,jobs,NULL)

用到的函数：

查看默认属性下，线程的退出状态：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include <fcntl.h>
 
int main()
{
    pthread_attr_t attr;
    //1.初始化线程属性
    pthread_attr_init(&attr);
    //2.检测线程属性中的线程退出状态
    int detach_status;
    pthread_attr_getdetachstate(&attr , &detach_status);
    //3.判断是回收态还是分离态
    if(detach_status == PTHREAD_CREATE_JOINABLE)
    {
        printf("线程属性默认为回收态\n");
    }
    else
    {
        printf("线程属性默认为分离态\n");
    }
    //4.释放线程属性结构体内存
    pthread_attr_destroy(&attr);
    printf("进程退出！\n");
}

线程互斥

互斥锁

pthread_mutex_t lock ; //定义一个互斥锁的结构体

pthread_mutex_init(&lock , &attr);       实现互斥锁的初始化

pthread_mutex_destroy(&lock);     释放锁资源所占用的内存 

pthread_mutex_lock(&lock);        上锁

pthread_mutex_unlock(&lock);     解锁

两个线程各对全局变量num++ 一共加5000次，每次加1 确保加的时候只有单一线程在操作不会造成线程冲突对数据错误修改。


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>
#include <fcntl.h>
 
//将次数定义成宏
#define CONT 5000
 
//将互斥锁与num定义成全局变量，来让两个线程都可以获取该锁和num
pthread_mutex_t lock;
int num = 0;
 
//两个线程的工作是一样的，所以这里只用定义一个工作函数
void* thread_job(void* arg)
{
    int i = 0;
    pthread_detach(pthread_self());//将线程设置为分离态，让系统自己回收
    //对num进行循环+1操作
    //注意，不要把锁加在循环外面，如果放在外面，就代表着让一个线程一次性加满5000次后再让另一个线程加
    //如果把锁家在循环外面，两个线程的工作效率还不如单线程工作效率高
    while(i < CONT)
    {
        pthread_mutex_lock(&lock);//上锁
        //这就是临界区代码，在上锁与解锁之间的代码就是临界区代码
        num++; 
        i++;
        printf("thread No.0x%x ++num , num = %d\n" , (unsigned int)pthread_self() , num);
        pthread_mutex_unlock(&lock);//解锁
    }
    pthread_exit(NULL);
}
 
int main()
{
    //初始化互斥锁
    pthread_mutex_init(&lock , NULL);
    pthread_t tids[2];
    //创造线程A和线程B
    pthread_create(&tids[0] , NULL , thread_job , NULL);
    pthread_create(&tids[1] , NULL , thread_job , NULL);
    //让主线程循环睡眠，来让线程A和线程B获取时间片
    //由于我们把线程设置成了分离态，系统会自动回收线程，不用我们操心
    while(1)
    {
        sleep(1);
    }
    //回收锁资源
    pthread_mutex_destroy(&lock);
    exit(0);
}

 读写锁

读锁可以多个线程同时读，写锁只允许一个线程写

读的时候不能写，写的时候不能读

定义num，创建八个线程，三个线程负责用写锁，五个线程用读锁

int number;  //全集变量num=0
pthread_rwlock_t lock;  //定义读写锁

void * write_thread(void * arg) //写线程
{
        while(1){
                pthread_rwlock_wrlock(&lock);  //申请写锁
                printf("writr 0x%x , ++number %d\n",(unsigned int)pthread_self(),++number);   //对num进行++操作，并打印出操作该线程的tid
                pthread_rwlock_unlock(&lock);   //解锁
                usleep(100000);
        }
}

void * read_thread(void *arg)
{
        while(1){
                pthread_rwlock_rdlock(&lock);
                printf("read 0x%x , number %d\n",(unsigned int)pthread_self(),number);
                pthread_rwlock_unlock(&lock);
                usleep(100000);
        }
}

int main(void)
{
        int i=0;
        pthread_t tids[8];  
        pthread_rwlock_init(&lock,NULL);   //初始化读写锁
        for(i;i<3;i++)
                pthread_create(&tids[i],NULL,write_thread,NULL);   //三个线程写锁
        for(i;i<8;i++)
                pthread_create(&tids[i],NULL,read_thread,NULL);    //后五个线程读锁
        while(i--){
                pthread_join(tids[i],NULL);     //线程全部回收
        }
        pthread_rwlock_destroy(&lock);          //释放锁资源
        return 0;
}

进程互斥锁

通过修改互斥锁的属性，将线程互斥锁变为进程互斥锁，让多进程使用 

pthread_mutex_init(&lock , &attr);       实现互斥锁的初始化 ，具体改变的就是互斥锁初始化的第二个参数。

例：

实现父子进程，分别对number++ 5000次

共享一个结构体，打包了共享数据number , 与pthread mutex_t进程互斥锁

没上锁的情况：

#include<sys/mman.h>
#include<sys/wait.h>

typedef struct
{
        int number;
        pthread_mutex_t lock;  //父子进程共享number，和一把锁
}shared_t;

int main(void)
{
        int fd;
        fd = open("MAP_FILE",O_RDWR);
        ftruncate(fd,sizeof(shared_t));    //共享文件开辟空间，大小为一个结构体

        //互斥锁属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setpshared(&attr,PTHREAD_PROCESS_SHARED);

        //映射
        shared_t * ptr = NULL;
        ptr = mmap(NULL,sizeof(shared_t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);  //共享成功，返回映射的首地址

        //初始化数据
        ptr->number = 0;
        pthread_mutex_init(&ptr->lock,&attr); //自定义锁属性初始化锁

        //父子进程
        pid_t pid;
        pid = fork();
        if(pid>0){
                for(int i=0;i<5000;i++){
                        printf("parent %d ++number %d\n",getpid(),++(ptr->number));
                }
                wait(NULL);    //防止僵尸进程，回收子进程
        }else if(pid == 0){
                for(int i=0;i<5000;i++){
                        printf("child %d ++number %d\n",getpid(),++(ptr->number));
                }
                exit(0);       //子进程先执行完退出，父回收
        }else{
                perror("fork failed");
        }
        printf("process done\n");
        return 0;
}

由于进程冲突，结果不稳定

上锁的情况：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/fcntl.h>
#include<pthread.h>
#include<signal.h>
#include<sys/mman.h>
#include<sys/wait.h>

typedef struct
{
        int number;
        pthread_mutex_t lock;  //父子进程共享number，和一把锁
}shared_t;

int main(void)
{
        int fd;
        fd = open("MAP_FILE",O_RDWR);
        ftruncate(fd,sizeof(shared_t));    //共享文件开辟空间，大小为一个结构体

        //互斥锁属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setpshared(&attr,PTHREAD_PROCESS_SHARED);

        //映射
        shared_t * ptr = NULL;
        ptr = mmap(NULL,sizeof(shared_t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);  //共享成功，返回映射的首地址

        //初始化数据
        ptr->number = 0;
        pthread_mutex_init(&ptr->lock,&attr); //自定义锁属性初始化锁

        //父子进程
        pid_t pid;
        pid = fork();
        if(pid>0){
                for(int i=0;i<5000;i++){
                        pthread_mutex_lock(&ptr->lock); //上锁
                        printf("parent %d ++number %d\n",getpid(),++(ptr->number));
                        pthread_mutex_unlock(&ptr->lock); //解锁
                }
                wait(NULL);    //防止僵尸进程，回收子进程
        }else if(pid == 0){
                for(int i=0;i<5000;i++){
                        pthread_mutex_lock(&ptr->lock);
                        printf("child %d ++number %d\n",getpid(),++(ptr->number));
                        pthread_mutex_unlock(&ptr->lock);
                }
                exit(0);       //子进程先执行完退出，父回收
        }else{
                perror("fork failed");
        }

        //释放资源 
        pthread_mutexattr_destroy(&attr);  //释放锁属性
        pthread_mutex_destroy(&ptr->lock);  //释放锁资源
        munmap(ptr,sizeof(shared_t));        //释放映射，释放顺序不能变，锁空间在映射空间内，应该先释放锁，再释放映射空间，否则会出现段错误
        printf("process done\n");
        return 0;
}

情况稳定，不管运行多少次都是10000 

 

文件锁 

 文件结构体里面有 文件锁属性结构体，其中包含了各种属性，如果想对文件锁属性进行修改，可以写一个新的结构体对旧的结构体进行替换从而修改文件锁属性

 两个进程对一个文件，进行上锁，解锁，又上锁，又解锁的操作。。。

线程同步

nclude<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/fcntl.h>
#include<pthread.h>
#include<signal.h>

int day;  //0表示黑天，1表示白天
pthread_cond_t day_cd, night_cd;   //线程挂在条件变量上
pthread_mutex_t lock;

void jobs(void)
{
        printf("thread 0x%x day [%d] ,执行巡逻任务\n",(unsigned int)pthread_self(),day);
}

void * thread_night(void * arg)
{
        while(1){
                pthread_mutex_lock(&lock);
                if(day == 1)    //如果是白天我就挂起
                        pthread_cond_wait(&night_cd,&lock);  //线程挂在条件变量上，并解锁
                //被唤醒了上锁
                jobs();
                ++day;
                pthread_mutex_unlock(&lock);
                pthread_cond_signal(&day_cd);
                usleep(100000);
        }

}

void * thread_day(void * arg)
{


        while(1){
                pthread_mutex_lock(&lock);
                if(day == 0)
                        pthread_cond_wait(&day_cd,&lock);  //挂起解锁
                //唤醒上锁
                jobs();
                --day;
                pthread_mutex_unlock(&lock);
                pthread_cond_signal(&night_cd);
                usleep(100000);
        }
}

int main(void)
{
        pthread_t tid;
        pthread_cond_init(&day_cd,NULL);
        pthread_cond_init(&night_cd,NULL);
        pthread_mutex_init(&lock,NULL);

        pthread_create(&tid,NULL,thread_day,NULL);
        pthread_create(&tid,NULL,thread_night,NULL);

        while(1)
                sleep(1);
        return 0;
}

生产者消费者：

NewBee_Lxx
关注
  • 24
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux c进程线程的面试问题,linux 多线程面试题_linux进程线程_linux 线程 pthread_create...
weixin_30910583的博客
04-29 1418
你写了一个简单的mandelbrot set程序，也就是说用ps命令行是可以看见多个线程，win32里同一个进程里各个线程之间是共享数据段的，win32的进程管理方式与unix上有着很大区别。adobe flash socket 、 activex htmlfile (ie) 、 基于 multipart 编码发送 xhr 、 基于长轮询的 xhr线程与进程的区别一个程序至少有一个进程,一个进程至...
Linux应用程序开发复习.docx
12-19
多线程编程 线程间的同步与互斥可以通过互斥锁、信号量等方式实现。互斥锁包括快速互斥锁、递归互斥锁、检错互斥锁等类型。 嵌入式Linux设备驱动开发 Linux的设备分类包括字符设备、块设备、网络设备等。设备驱动...
linux系统编程重点复习09--线程同步
cat_fish_rain的博客
07-31 96
第二种 线程A拥有A锁，请求获得B锁；上述代码中，生产者线程调用pthread_cond_signal函数会使消费者线程在pthread_cond_wait处解除阻塞。死锁并不是linux提供给用户的一种使用方法，而是由于用户使用互斥锁不当引起的一种现象。练习：3个线程不定时写同一全局资源，5个线程不定时读同一全局资源。读并行，写独占，当读写同时等待锁的时候写的优先级高。
Linux复习之线程管理
qq2904529388的博客
03-19 366
线程是进程里面单一的执行控制序列（执行流），也是cpu调度的基本单位（分配给cpu执行最小单位），假如进程的运行是为了完成某个任务，线程是该任务的许多子任务之一，线程的创建，操作系统并不会给它分配内存资源，进程中所有线程共享所属进程地址空间上的资源。如果进程里只有一个线程，也就是只有一个线程在cpu中执行该进程的代码和数据。如果有多个线程，那么这些线程轮流在cpu中执行该进程的代码和数据。在linux中，线程是在进程的基础改的。
Linux之多线程
cls的博客
03-25 1066
挂起失败就是函数调用失败，你就不能把自己放到等待队列里，继续向后走。条件可能并没有满足，但是我这个线程被唤醒了。比如很多线程在条件变量下等，等的时候 （在多CPU的情况下被唤醒），虽然大家会排队，但是在多CPU下执行代码的时候，有可能向目标条件变量发送条件就绪这样的指令，最后可能导致当前的线程被伪唤醒。再比如：我们现在的代码是只要别人生产一条数据，就把消费者唤醒了。
linux多线程
m0_51641706的博客
03-08 751
线程概念 进程是承担分配系统资源的基本实体 线程是调度的基本单位，线程是进程里面的执行流。（线程在进程的地址空间里面运行） 进程：线程 = 1 ： n 一切进程至少都有一个执行线程 线程在进程内部运行，本质是在进程地址空间内运行 CPU在管理进程的时候只看pcb（因为一个pcb代表一个执行流），在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。原因就是因为线程没有很多的数据结构去管理 linux中，没有真正意义上的线程。（没有为线程设计数据结构，windows
「复习」Linux线程复习思维导图
zheshuiyu的博客
09-05 64
本思维导图涵盖了Linux线程的基本知识、线程与进程的异同、互斥锁、线程同步、生产者消费者模型等相关知识。
Linux期末复习——多线程编程
l5j12138的博客
10-31 199
Linux期末复习——多线程编程
Linux多线程开发
Q_Outsider的博客
06-20 228
操作系统线程详细复习~
嵌入式linux下多线程编程,多线程编程之：Linux线程编程-嵌入式系统-与非网
weixin_29230805的博客
05-05 575
9.2 Linux线程编程9.2.1 线程基本编程这里要讲的线程相关操作都是用户空间中的线程的操作。在Linux中，一般pthread线程库是一套通用的线程库，是由POSIX提出的，因此具有很好的可移植性。(1)函数说明。创建线程实际上就是确定调用该线程函数的入口点，这里通常使用的函数是pthread_create()。在线程创建以后，就开始运行相关的线程函数，在该函数运行完之后，该线程也就退...
Linux期末复习题.docx
06-09
Linux的特点包括多用户、多线程和多CPU支持，这使得它能够高效地处理并发任务。 对Linux系统中网络接口的配置，如eth0的IP地址设置，需要修改/etc/sysconfig/network-scripts/ifcfg-eth0文件。VMware虚拟网络提供了...
Linux内核复习.docx
12-18
此外，Linux内核还支持对称多处理（SMP），允许多个处理器同时执行任务，提高了系统效率。 在Linux内核版本管理方面，偶数版本号表示稳定版，奇数版本号则代表开发中的版本。例如，版本号2.6.30.1中的6表明这是一个...
linux客观题复习题
01-10
* Linux 是一种类 Unix 的操作系统，具有多用户、多任务、多线程等特点。 二、Linux 命令 * 删除文件命令：rm * 查看文件内容命令：cat * 显示当前目录命令：pwd * 列出目录下的所有文件命令：ls -a * 创建文件...
Linux考试题复习 带答案
12-29
本资源摘要信息是关于 Linux 考试题复习的详细笔记，涵盖了操作系统的基本概念、文件系统、权限管理、命令使用等多方面的知识点。 一、操作系统基本概念 * 操作系统是计算机系统中最基本的软件，直接管理和控制...
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
weixin_42333261的博客
07-12 160
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
linux的学习（四）：磁盘，进程，定时，软件包的相关命令
最新发布
weixin_45037073的博客
07-14 803
关于磁盘管理，进程管理，定时任务，软件包管理的命令的使用。
Linux 安装 Docker Compose
m0_63004677的博客
07-12 307
Linux 系统安装 Docker Compose
【Linux】 GCC/G++与Makefile使用
Long_kin的博客
07-11 990
收藏向 使用解析

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值