linux——线程

最新推荐文章于 2024-09-30 08:05:35 发布
最新推荐文章于 2024-09-30 08:05:35 发布
阅读量376 收藏 7
点赞数 5
分类专栏： Linux线程 文章标签： linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITQWQ/article/details/140072832
版权

在 Linux 系统中，进程和线程是两种重要的并发执行单元。本文将详细介绍它们的区别、使用场景、以及多线程编程中的关键API和示例代码。

进程与线程的区别

进程

  • 进程是程序运行的一个实例，承担分配系统资源的基本单位。
  • 每个进程都有独立的地址空间，一个进程崩溃不会影响其他进程。
  • 进程的创建和切换消耗较多资源。

线程

  • 线程是进程中的一个执行路径，是CPU调度的基本单位。
  • 线程共享进程的地址空间，但每个线程有自己的堆栈和局部变量。
  • 线程的创建和切换开销较小。
  • 如果一个线程崩溃，会导致整个进程崩溃。

使用线程的理由

  1. 节省资源：创建进程需要分配独立的地址空间，建立多个数据表来维护其代码段、数据段和堆栈段，这种方式十分昂贵。线程共享同一进程的地址空间和大部分数据，启动一个线程比启动一个进程要快很多。一个进程的开销大约是一个线程的30倍。
  2. 方便的通信机制：不同进程之间的数据传递需要通过通信机制，如管道、信号等，这种方式耗时且复杂。而线程共享进程的数据空间，数据共享非常方便和快捷，但需要注意数据同步的问题。

多线程开发及API

多线程开发主要包含三点：线程、互斥锁、条件变量。以下是具体的操作和API介绍：

线程操作

线程的创建
#include <pthread.h>
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
// 返回：若成功返回0，否则返回错误编号
线程的获取和比较
#include <pthread.h>
pthread_t pthread_self(void);
线程的等待
#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// 参数：
// pthread_t thread：等待的线程
// void **rval：线程退出状态的收回，NULL表示不收回
线程的退出
#include <pthread.h>
int pthread_exit(void *rval_ptr);

线程的创建、退出、等待示例

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

void *func1(void *arg)
{
   static int ret = 10;
   printf("t1:%ld thread is created\n", (unsigned long)pthread_self());
   printf("t1: parameter is %d\n", *((int *)arg));
   pthread_exit((void*)&ret); // 线程退出
}

int main()
{
    int ret;
    int param = 100;
    int *pret = NULL;
    pthread_t t1;

    ret = pthread_create(&t1, NULL, func1, (void*)&param); // 创建线程
    if(ret == 0){
        printf("main: create t1 success\n");
    }
    printf("main: %ld\n", (unsigned long)pthread_self()); // 获取线程ID
   
    pthread_join(t1, (void**)&pret); // 等待线程退出
    printf("main: t1 quit with %d\n", *pret);
    return 0;
}

传入一个结构体的线程创建示例

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

struct data
{
    int a;
    char *s;
};

void *func1(void *arg)
{
    static char *x = "t1 run out";
    struct data *temp;
    temp = (struct data*)arg;
    printf("t1:%ld pthread is created\n", (unsigned long)pthread_self());
    printf("t1: %d\n", temp->a);
    printf("t1: %s\n", temp->s);
    pthread_exit((void*)x);
}

int main()
{
    int ret;
    pthread_t t1;
    char *pret = NULL;
    struct data *p = (struct data*)malloc(sizeof(struct data));
    p->a = 1;
    p->s = "xiancheng";
    
    ret = pthread_create(&t1, NULL, func1, (void*)p);
    if(ret == 0){
        printf("main: create t1 success\n");
    }
    
    printf("main: %ld\n", (unsigned long)pthread_self());

    pthread_join(t1, (void**)&pret);
    printf("main: t1 quit with %s\n", pret);
    free(p);
    return 0;
}

线程共享空间验证示例

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

int g_data = 10;

void *func1(void *arg)
{
    printf("t1:%ld thread is created\n", (unsigned long)pthread_self());
    printf("t1: parameter is %d\n", *((int*)arg));
    while(1){
        printf("%d\n", g_data++);
        sleep(1);
        if(g_data == 3){
            pthread_exit(NULL);
        }
    }
}

void *func2(void *arg)
{
    printf("t2:%ld thread is created\n", (unsigned long)pthread_self());
    printf("t2: parameter is %d\n", *((int*)arg));
    while(1){
        printf("%d\n", g_data++);
        sleep(1);
    }
}

int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
    
    ret = pthread_create(&t1, NULL, func1, (void*)&param);
    if(ret == 0){
        printf("main: create t1 success\n");
    }
    
    ret = pthread_create(&t2, NULL, func2, (void*)&param);
    if(ret == 0){
        printf("main: create t2 success\n");
    }

    printf("main: %ld\n", (unsigned long)pthread_self());
    while(1){
        printf("%d\n", g_data++);
        sleep(1);
    } 
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
  
    return 0;
}

互斥锁（Mutex）

互斥锁API
创建及销毁互斥锁
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *restrict mutex);
加锁及解锁
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *restrict mutex);
int pthread_mutex_trylock(pthread_mutex_t *restrict mutex);
int pthread_mutex_unlock(pthread_mutex_t *restrict mutex);

使用互斥锁的示例

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

int g_data = 0;
pthread_mutex_t mutex; // 定义锁

void *func1(void *arg)
{
    pthread_mutex_lock(&mutex); // 加锁
    for(int i = 0; i < 5; i++){
        printf("t1: %ld thread is created\n", (unsigned long)pthread_self());
        printf("t1: parameter is %d\n", *((int*)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex); // 解锁
}

void *func2(void *arg)
{
    pthread_mutex_lock(&mutex);
    for(int i = 0; i < 5; i++){
        printf("t2: %ld thread is created\n", (unsigned long)pthread_self());
        printf("t2: parameter is %d\n", *((int*)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
}

void *func3(void *arg)
{
    pthread_mutex_lock(&mutex);
    for(int i = 0; i < 5; i++){
        printf("t3: %ld thread is created\n", (unsigned long)pthread_self());
        printf("t3: parameter is %d\n", *((int*)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
}

int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
    pthread_t t3;
     
    pthread_mutex_init(&mutex, NULL); // 初始化锁
     
    ret = pthread_create(&t1, NULL, func1, (void*)&param);
    if(ret == 0){
        printf("main: create t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2, (void*)&param);
    if(ret == 0){
        printf("main: create t2 success\n");
    }

    ret = pthread_create(&t3, NULL, func3, (void*)&param);
    if(ret == 0){
        printf("main: create t3 success\n");
    }

    printf("main: %ld\n", (unsigned long)pthread_self());

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
     
    pthread_mutex_destroy(&mutex); // 收回锁
    
    return 0;
}

互斥锁限制共享资源的访问示例

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

int g_data = 0;
pthread_mutex_t mutex;

void *func1(void *arg)
{
    printf("t1: %ld pthread is created\n", (unsigned long)pthread_self());
    printf("t1: parameter is %d\n", *((int*)arg));
    while(1){
        pthread_mutex_lock(&mutex);
        printf("%d\n", g_data++);
        sleep(1);
        if(g_data == 3){
            pthread_mutex_unlock(&mutex);
            pthread_exit(NULL);
        }
    }
}

void *func2(void *arg)
{
    printf("t2: %ld pthread is created\n", (unsigned long)pthread_self());
    printf("t2: parameter is %d\n", *((int*)arg));
    while(1){
        printf("%d\n", g_data);
        pthread_mutex_lock(&mutex);
        g_data++;
        pthread_mutex_unlock(&mutex);
        sleep(1); 
    }
}

int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
     
    pthread_mutex_init(&mutex, NULL);
     
    ret = pthread_create(&t1, NULL, func1, (void*)&param);
    if(ret == 0){
        printf("main: create t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2, (void*)&param);
    if(ret == 0){
        printf("main: create t2 success\n");
    }

    printf("main: %ld\n", (unsigned long)pthread_self());

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
     
    pthread_mutex_destroy(&mutex);
    return 0;
}

死锁示例

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

pthread_mutex_t mutex;
pthread_mutex_t mutex2;

void *func1(void *arg)
{
    pthread_mutex_lock(&mutex);
    sleep(1);
    pthread_mutex_lock(&mutex2);
    for(int i = 0; i < 5; i++){
        printf("t1: %ld\n", (unsigned long)pthread_self());
        printf("t1: parameter is %d\n", *((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex2);
}

void *func2(void *arg)
{
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex);
    for(int i = 0; i < 5; i++){
        printf("t2: %ld\n", (unsigned long)pthread_self());
        printf("t2: parameter is %d\n", *((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex);
}

void *func3(void *arg)
{
    pthread_mutex_lock(&mutex);
    for(int i = 0; i < 5; i++){
        printf("t3: %ld\n", (unsigned long)pthread_self());
        printf("t3: parameter is %d\n", *((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
}

int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
    pthread_t t3;
    
    pthread_mutex_init(&mutex, NULL);
    pthread_mutex_init(&mutex2, NULL);

    ret = pthread_create(&t1, NULL, func1, (void*)&param);
    if(ret == 0){
        printf("main: create t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2, (void*)&param);
    if(ret == 0){
        printf("main: create t2 success\n");
    }

    ret = pthread_create(&t3, NULL, func3, (void*)&param);
    if(ret == 0){
        printf("main: create t3 success\n");
    }

    printf("main: %ld\n", (unsigned long)pthread_self());

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    
    pthread_mutex_destroy(&mutex);
    pthread_mutex_destroy(&mutex2);
   
    return 0;
}

条件变量实现线程同步

条件变量API
创建及销毁条件变量
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);
等待
#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);
触发
#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *restrict cond);
int pthread_cond_broadcast(pthread_cond_t cond);

使用条件变量的示例

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

int g_data = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;

void *func1(void *arg)
{
    static int cnt = 10;
    printf("t1: %ld pthread is created\n", (unsigned long)pthread_self());
    printf("t1: parameter is %d\n", *((int*)arg));
    while(1){
        pthread_cond_wait(&cond, &mutex); // 等待
        if(g_data == 3){
            printf("t1 run=========================\n");
        }
        printf("t1: %d\n", g_data);
        g_data = 0;
        sleep(1);
        if(cnt++ == 10){
            exit(1);
        }
    }
}

void *func2(void *arg)
{
    printf("t2: %ld pthread is created\n", (unsigned long)pthread_self());
    printf("t2: parameter is %d\n", *((int*)arg));
    while(1){
        printf("t2: %d\n", g_data);
        pthread_mutex_lock(&mutex);
        printf("%d\n", g_data++);
        if(g_data == 3){
            pthread_cond_signal(&cond); // 触发
        }
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}

int main()
{
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;

    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);

    ret = pthread_create(&t1, NULL, func1, (void *)&param);
    if(ret == 0){
        printf("main: create t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2, (void *)&param);
    if(ret == 0){
        printf("main: create t2 success\n");
    }
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

通过上述示例和API的讲解，本文详细介绍了Linux下进程与线程的区别、多线程开发的基本操作以及常见问题和解决方案。希望能够帮助大家更好地理解和使用多线程编程。

琢瑜
关注
专栏目录
Linux——线程深度剖析（二），拿下线程安全
cckluv的博客
11-29 3168
Linux——线程深度剖析（二）互斥同步临界资源临界区线程安全如何保证线程安全0.互斥锁1.互斥锁的初始化2.加锁3.解锁4.互斥锁的销毁实例的运用：黄牛抢票 互斥 是指散布在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它 们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。 同步 散步在不同进程之间的若干程序片断，它们的运行必须严格按照规定的 某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。 临界资源 多个线程共享的资源 临界区
Linux——线程的创建
热门推荐
qq_44824574的博客
12-04 1万+
线程的概念与实现方式 线程是进程内部的一条执行序列或执行路径，一个进程可以包含多条线程。 执行序列就是一组有序指令得到集合——函数。 线程是进程内部的一条执行序列，一个进程至少有一条线程，称之为主线程（main方法代表的执行序列），可以通过线程库创建其他线程（给线程制定一个它要执行的函数），将创建的线程称之为函数线程。 线程的实现方式 内核级线程（线程的实现（创建、调度、销毁）由操作系统的内核来完成） 用户级线程（操作系统内核并不支持多线程，线程的实现都是在用户态） 混合级线程（结合以上两种方式实现）
Linux —— 线程同步
qq_67693066的博客
05-19 897
Linux —— 线程同步
Linux——线程互斥与互斥锁的使用
kkbca的博客
04-07 1751
由于线程可以创建多个，也就是操作系统中存在多个由某一个进程创建的执行流。那么他们在访问并修改共享资源时，可能会发生数据不一致的问题，进而我们需要让线程互斥来保护公共资源。
Linux —— 线程
qq_67693066的博客
05-12 1380
Linux —— 线程
Linux —— 线程控制
qq_67693066的博客
05-14 1205
Linux —— 线程控制
Linux —— 线程互斥
qq_67693066的博客
05-17 1033
Linux —— 线程互斥
linux——多线程，线程控制
qq_63943454的博客
10-10 1918
线程控制，对线程的创建，退出，等待，分离的操作，后续还有，同步，互斥，等控制。以达到对线程更好的管理和利用。
Linux —— 多线程
M的博客
08-05 6039
目录一、线程的概念1.理解线程 2.线程的优点3.线程的缺点 4.线程异常5.线程用途二、Linux进程VS线程 1.进程和线程2.进程的多个线程共享3.进程和线程的关系三、Linux线程控制1.POIX线程库2.线程创建3.线程等待4.线程终止5.分离线程6.线程ID及进程地址空间布局 如何理解之前的进程？CPU如何看待task_struct？Linux下并不存在真正的线程？而是用进程模拟的？......
Linux系统编程——线程私有数据-附件资源
03-02
Linux系统编程——线程私有数据-附件资源
Linux——线程详解
m0_46657980的博客
01-11 475
1. 线程的概念 1.1 基本概念 线程是进程中的一条执行流，是CPU调度的基本单位，一个进程中可以有多个线程 Linux下的线程执行流是通过pcb实现的，且一个进程中可能有多个pcb，并且这些pcb共享同一个进程中的大部分资源，因此，也被称为轻量级进程 Linux下，线程是CPU调度的基本单位，进程是系统进行资源分配的基本单位 1.2 线程之间的独有与共享 共享：虚拟地址空间（代码段和数据段）、文件描述符表、信号处理方式、工作路径 独有：线程栈、寄存器、信号屏蔽字、优先级、errno、线程标
Linux——线程1 | 用C创建线程、循环创建多个子线程
qq_37299596的博客
05-05 4629
一、线程基础 进程：有独立的进程地址空间，有独立的pcb 线程：有独立的pcb，没有独立的进程地址空间 因此进程线程最本质的区别就是：是否共享地址空间 在Linux下线程是最小的执行单位；进程是最小的分配资源单位，可看成只有一个线程的进程 看进程下的线程号：ps -Lf 进程ID LWP—>CPU执行的最小单位 线程共享和非共享 线程共享资源： 1，文件描述符表 2，每种信号的处理方式...
Linux——线程2(过）| pthread_exit、pthread_join、pthread_detach、线程属性设置分离线程
qq_37299596的博客
05-06 716
比较几个退出函数 pthread_exit()：退出当前线程 exit()：退出当前进程 return：返回到调用者那里去 一、pthread_exit函数：将单个线程退出 void pthread_exit(void *retval); 参数retval表示线程退出状态，通常传NULL 在线程中，禁止使用exit函数，因为会导致进程内所有线程全部退出，因此在多线程环境中，应尽量少用exit函数...
Linux——多线程编程
weixin_51526796的博客
03-29 761
•。
在 Kali Linux 中安装 Impacket
最新发布
weixin_44023460的博客
09-30 230
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux 安装redis主从模式+哨兵模式3台节点
一千个读者就有一千个哈姆雷特
09-27 409
Linux 安装redis主从模式+哨兵模式3台节点
linux 源代码编译
Lxn2zh的博客
09-27 1351
有时候会在linux上下载源码包，然后进行编译成可执行的文件，这个过程需要经过configure、make、make install、make clean四个步骤。configure 为这个程序在当前的操作系统环境下选择合适的编译器和环境参数来编译该代码。make install 将已编译好的可执行文件安装到操作系统指定或默认的安装目录下。make 对程序代码进行编译操作，会将源码编译成可执行的目标文件。make clean 删除编译时临时产生的目录或文件。
[Linux]：线程(一)
Bettysweetyaaa的博客
09-26 750
想深入了解线程吗？本文将为你详细解读线程的概念、优缺点、异常及用途，还介绍了 Linux 中线程的控制方法。快来阅读，提升你的编程技能，探索多线程的奥秘！
Unix/Linux多线程编程教程——POSIX线程解析
"该资源是一个关于POSIX线程的Unix教程，主要涵盖了Unix/Linux操作系统的内核编程，包括内存管理、文件I/O、进程管理、信号、进程间通信以及多线程等内容。此外，还介绍了Unix环境下的开发工具，特别是GCC编译器的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值