首页 > 其他分享 >多线程（一）

多线程（一）

时间：2024-03-19 13:35:21浏览次数：34  
标签：多线程 void pthread 线程 printf tid include

1、线程与进程

进程：一个正在执行的程序，是资源分配的最小单位 1）进程中的事情需要按照一定的顺序逐个执行，那么如何让一个进程中的一些事情同时执行？ 2）进程出现了很多弊端：一是由于进程是资源拥有者，创建、撤销与切换存在较大的时空开销，因此需要引入轻量级进程；二是由于多处理器（SMP）出现，可以满足多个运行单位，而多个进程并行开销过大。 线程：又称为轻量级进程，程序执行的最小单位，系统调度和分配cpu的基本单位，他是进程中的一个实体。一个进程中可以有多个线程，这些线程共享进程的所有资源，线程本身只包含一点必不可少的资源。 进程负责申请资源，从主函数开始就是一个线程了。 进程申请资源，多线程中的各个线程共享线程中的资源 进程申请资源，多进程使用fork()函数来进行创建子进程 1、fork拷贝会消耗资源 2、进程间通信还要经过管道，消息队列，信号量来进行通信比较复杂 进程与线程之间的区别： 1）进程有自己独立的地址空间，多个线程共用同一个地址空间 2）线程更加节省系统资源 3）在一个地址空间中多个线程共享，每个线程都有属于自己的栈区 4）每一个地址空间中多个线程独享，代码区、堆区、数据区、打开的文件（文件描述符）都是线程共享的 5）每个进程对应一个虚拟地址空间，一个进程只能抢一个CPU时间片 6）在一个地址空间中可以划分出多个线程，在有效的资源基础上，能够抢到更多的CPU时间片 CPU调度和切换：线程上下文切换比进程要快的多 上下文切换：进程/线程分时复用CPU时间片，在切换之前会将上一次任务的状态进行保存，下次切换回这个任务的时候，加载这个状态继续执行，任务从保存到再次加载的这个过程就是一次上下文切换。 进程更加廉价，启动速度更快，退出也快，对系统资源的冲击较小 在处理多任务程序的时候使用多线程比使用多进程要更有优势，但是并不是线程并不是越多越好。  

2、线程的一些术语

1、并发是指同一时刻，只有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。看起来同时发生，针对单核处理器的 2、并行是指在同一时刻，有多条指令在多个处理器上（cpu）同时执行。真正的同时发生 3、同步：彼此有依赖关系的调用不应该 “同时发生”，而同步就是要阻止那些 “同时发生” 的事情 4、异步：异步的概念与同步相对，任何两个彼此独立的操作是异步的，它表明事情独立的发生 多线程的优势： 1、在多处理器中开发程序的并行性 2、在等待IO操作时，程序可以执行其他操作，提高并发性 3、模块化的编程，能更清晰的表达程序中独立事件的关系，结构清晰 4、占用较少的系统资源，相对于多进程而言 5、多线程不一定要多处理器，多处理器只是提高了并行性  

3、线程创建函数

创建出来的是子线程，当单进程程序中创建线程的时候，进程便退化成了主线程。线程与进程的标识符类型、获取id的函数、线程创建函数分别如下图所示： 0 pthread_create函数的使用如下： 
#include<pthread.h>
 
int  pthread_create(pthread_t *tidp, const  pthread_attr_t *attr,
                            ( void *)(*start_rtn)( void *), void  *arg);
                           
参数说明：
thread：传出参数、是无符号长整型数，会将线程id写到这个指针指向的内存中
attr：线程属性，一般为空
start_rtn：是线程运行函数的起始地址         
arg：运行函数的参数     
 
返回值：
线程创建成功，则返回0，创建失败返回错误参数   
 
编译方法：
-lpthread //pthread为动态库
例如：
gcc test.c -lpthread -o test
测试demo： 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
 
void print_id(char *s)
{
        printf("%s :pid is %u tid is %ld\n", s, getpid(), pthread_self());
}
 
void* callback(void *arg)
{
        print_id(arg);
        for (int i = 0; i < 5; i++) {
                printf("子线程: i = %d\n", i);
        }
        printf("子线程: %ld\n", pthread_self());
 
        return (void *)0;
}
 
int main()
{
        pthread_t tid;
        pthread_create(&tid, NULL, callback, "new thread");
        for (int i = 0; i < 5; i++) {
                printf("主线程: i = %d\n", i);
        }
 
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
        printf("主线程: %ld\n", pthread_self());
        // sleep(2);
        
        return 0;
}
执行结果一 
主线程: i = 0
主线程: i = 1
主线程: i = 2
主线程: i = 3
主线程: i = 4
pid is 23801 tid is 139896767649536
主线程: 139896767649536
当我们打开sleep(2)的注释，执行结果二如下： 
主线程: i = 0
主线程: i = 1
主线程: i = 2
主线程: i = 3
主线程: i = 4
pid is 23892 tid is 140477647664896
主线程: 140477647664896
new thread :pid is 23892 tid is 140477639358208
子线程: i = 0
子线程: i = 1
子线程: i = 2
子线程: i = 3
子线程: i = 4
子线程: 140477639358208
解释： 程序从main函数开始执行，执行到pthread_create函数时，会创建callback的子线程执行callback函数里面的相关代码，同时main函数里面也继续向下执行，main函数执行完毕后就会释放掉相关虚拟地址空间资源，这时候callback子线程还没有运行完，这时就会执行出现结果一。当我们在主线程中sleep(2);就可以延长虚拟地址空间的生命周期，就可以正常执行完子线程的相关内容了。  

4、线程退出函数

在编写多线程程序时，如果想让线程退出，但是不会导致虚拟地址空间资源的释放，我们就可以调用线程库中的线程退出函数，只要调用该函数当前线程就立马退出了，并且不会影响到其他线程的正常运行，不管是子线程还是主线程中都适用。 
#include <pthread.h>

void pthread_exit(void *retval);

参数说明：
retval：void*类型的指针，指向的数据将作为线程退出时的返回值。如果线程不需要返回任何数据，直接设为NULL即可
测试demo： 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
 
void print_id(char *s)
{
        printf("%s :pid is %u tid is %ld\n", s, getpid(), pthread_self());
}
 
void* callback(void *arg)
{
        print_id(arg);
        for (int i = 0; i < 5; i++) {
                printf("子线程: i = %d\n", i);
        }
        printf("子线程: %ld\n", pthread_self());
 
        return (void *)0;
}
 
int main()
{
        pthread_t tid;
        pthread_create(&tid, NULL, callback, "new thread");
 
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
        printf("主线程: %ld\n", pthread_self());
        pthread_exit(NULL);        
 
        return 0;
}
执行结果： 
pid is 25055 tid is 140031551674112
主线程: 140031551674112
new thread :pid is 25055 tid is 140031543367424
子线程: i = 0
子线程: i = 1
子线程: i = 2
子线程: i = 3
子线程: i = 4
子线程: 140031543367424
将第三点创建线程中的例子对比可以看出，pthread_exit函数将主线程退出了，但是并没有释放虚拟地址空间资源。  

5、线程回收函数

线程和进程一样，子线程退出的时候其内核资源主要由主线程回收，线程库中提供的线程回收函数是pthread_join()，这个函数是一个阻塞函数，如果还有子线程运行，调用该函数就会阻塞，子线程退出函数解除阻塞进行资源的回收，函数被调用一次，只能回收一个子线程，如果有多个子线程则需要循环进行回收操作。 另外通过线程回收函数还可以获取到子线程退出时传递出来的数据，如下： 
#include <pthread.h>
 
int pthread_join(pthread_t thread, void **retval);
 
参数说明：
thread：等待退出线程的线程号
retval：退出线程的返回值，二级指针，是一个传出函数，这个地址中存储了pthread_exit()传递出的数据，如果不需要，可以为NULL
 
返回值：线程回收成功返回0，回收失败返回错误号
测试demo： 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
 
struct test
{
        int num;
        int age;
};
 
struct test t;        // 全局变量多线程共享
 
void print_id(char *s)
{
        printf("%s :pid is %u tid is %ld\n", s, getpid(), pthread_self());
}
 
void* callback(void *arg)
{
        print_id(arg);
        for (int i = 0; i < 5; i++) {
                printf("子线程: i = %d\n", i);
        }
 
        // struct test t;    栈区被释放了，所以test不能是局部变量，定义1
        t.num = 100;
        t.age = 50;
 
        pthread_exit(&t);
 
        printf("子线程: %ld\n", pthread_self());
 
        return (void *)0;
}
 
int main()
{
        pthread_t tid;
        pthread_create(&tid, NULL, callback, "new thread");
 
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
        printf("主线程: %ld\n", pthread_self());
 
        void *ptr;        // ptr指向pthread_exit退出时t的地址
        pthread_join(tid, &ptr);
        struct test *pt = (struct test*)ptr;
        printf("num: %d, age = %d\n", pt->num, pt->age);
 
        return 0;
}
执行结果： 
pid is 26531 tid is 139762155865856
主线程: 139762155865856
new thread :pid is 26531 tid is 139762147559168
子线程: i = 0
子线程: i = 1
子线程: i = 2
子线程: i = 3
子线程: i = 4
num: 100, age = 50
分析：test t不能定义在1处，因为test t是子线程里面的栈内存，在一块虚拟内存空间中，只有一个栈，这个栈被多个子线程均分了，一个子线程退出，子线程所使用的栈就被释放了，我们取出来的其实是随机数。如果保证数据正确呢？要保证这块地址不被释放就可以了，可以使用堆内存，也可以是全局变量，因为多线程共享全局数据区和堆区，只要保证多个线程能够访问这块内存就可以了。 测试demo2： 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
 
struct test
{
        int num;
        int age;
};
 
// struct test t;        // 全局变量多线程共享
 
void print_id(char *s)
{
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
}
 
void* callback(void *arg)
{
        print_id(arg);
        for (int i = 0; i < 5; i++) {
                printf("子线程: i = %d\n", i);
        }
 
        struct test*t = (struct test*)arg;
        // struct test t;    栈区被释放了，所以test不能是局部变量
        t->num = 100;
        t->age = 50;
 
        pthread_exit(t);
 
        printf("子线程: %ld\n", pthread_self());
 
        return (void *)0;
}
 
int main()
{
        struct test t;
        pthread_t tid;
        pthread_create(&tid, NULL, callback, &t);
 
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
        printf("主线程: %ld\n", pthread_self());
 
        void *ptr;        // ptr指向pthread_exit退出时t的地址
        pthread_join(tid, &ptr);
        struct test *pt = (struct test*)ptr;
        printf("num: %d, age = %d\n", pt->num, pt->age);
 
        return 0;
}
执行结果： 
pid is 27333 tid is 140069782001408
主线程: 140069782001408
pid is 27333 tid is 140069773694720
子线程: i = 0
子线程: i = 1
子线程: i = 2
子线程: i = 3
子线程: i = 4
num: 100, age = 50
分析：多个线程把栈空间给平分了，多线程中不能访问相应的栈空间的，但是主动将主线程的栈空间传递给子线程，那么就可以访问了，主线程和子线程都是同一个虚拟地址空间的，所以可以访问到。当子线程释放掉，主线程栈空间还是存在的，调用的时候是可以正常执行的。  

6、线程分离函数

一般情况下，程序中的主线程有属于自己的处理流程，如果让主线程负责子线程的资源回收，调用pthread_join()只要子线程不退出就会被一直阻塞，那么主线程的任务也不能被执行了 在线程库函数中为我们提供了线程分离函数pthread_detach()，调用这个函数之后指定的子线程可以跟主线程分离，当子线程退出的时候，其占用的内核资源就被系统的其他进程接管并回收了。线程分离之后主线程中使用pthread_join()就回收不到子线程资源了。 
#include <pthread.h>
int pthread_detach(pthread_t thread);

参数解释：
thread：线程id
测试demo： 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>

struct test
{
        int num;
        int age;
};
 
void print_id(char *s)
{
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
}
 
void* callback(void *arg)
{
        print_id(arg);
        for (int i = 0; i < 5; i++) {
                printf("子线程: i = %d\n", i);
        }
 
        struct test*t = (struct test*)arg;
        t->num = 100;
        t->age = 50;
 
        pthread_exit(t);
 
        printf("子线程: %ld\n", pthread_self());
 
        return (void *)0;
}
 
int main()
{
        struct test t;
        pthread_t tid;
        pthread_create(&tid, NULL, callback, &t);
 
        printf("pid is %u tid is %ld\n", getpid(), pthread_self());
        printf("主线程: %ld\n", pthread_self());
 
        pthread_detach(tid);
        pthread_exit(NULL);
 
        return 0;
}
执行结果： 
pid is 28021 tid is 140366746593024
主线程: 140366746593024
pid is 28021 tid is 140366738286336
子线程: i = 0
子线程: i = 1
子线程: i = 2
子线程: i = 3
子线程: i = 4
分析：使用pthread_detach函数就可以直接将子线程与主线程的分离，子线程函数执行完后退出，由内核的函数自动回收，主线程也不会被阻塞。  

7、线程取消函数

线程取消函数的意思就是在某些特定的情况下在一个线程中杀死另外一个线程，使用这个函数杀死另外一个线程需要分两步： 1）在线程A中调用线程取消函数pthread_cancel，指定取消线程B，这是B是被取消不了的 2）线程B进行一次系统调用（用用户态切换到内核态），否则线程B可以一直运行 
#include <pthread.h>
int pthread_cancel(pthread_t pid);

参数：线程号
返回值：成功返回0，失败返回错误码
第二点比如执行printf进行打印，printf最终会写终端，因此在底层会调用read方法。  

8、线程ID比较函数

在linux中线程ID本质就是一个无符号长整形，因此可以直接使用比较操作符比较两个线程的ID： 
#include <pthread.h>

int pthread_equal(pthread_t t1, pthread_t t2);

返回值：ID相等返回值不等于0，不相等返回值等于0
 

标签：多线程,void,pthread,线程,printf,tid,include
From： https://www.cnblogs.com/lethe1203/p/18082563

相关文章

  • JAVA多线程常用方法
    文章目录1.常用方法总结2.run和start3.sleep4.yield5.join6.interrupt6.1相关方法6.2打断park线程6.3过时方法7.守护线程8.线程状态8.1操作系统中8.2Java中1.常用方法总结Thread类的常用API如下：方法说明publicvoidstart()启动一个新线程，Java虚拟......
  • Java中的多线程是如何实现的？
    ​​​​​​继承Thread类：通过继承Java的Thread类并重写其run()方法，可以创建一个线程。run()方法包含了线程要执行的代码。创建Thread子类的实例，并调用其start()方法来启动线程。start()方法会导致线程开始执行，自动调用run()方法。注意：Java不支持多重继承，因此如果类已经继承了......
  • 多线程-初阶
    1.认识线程（Thread）1.1概念1)线程是什么一个线程就是一个"执行流".每个线程之间都可以按照顺讯执行自己的代码.多个线程之间"同时"执行着多份代码.还是回到我们之前的银行的例子中。之前我们主要描述的是个人业务，即一个人完全处理自己的业务。我们进一步设想如......
  • Spring高级特性@Enable*注解的应用之：计划任务和多线程
     Spring高级特性之三：@Enable*注解的工作原理和@Enable*注解的应用之：声明式事务@EnableTransactionManagement详解中对于@EnableXXX相关应用已有总结：1）@EnableXXX启动XXX应用，比如@EnableTransactionManagement开启声明式事务管理， 2）具体被操作管理执行对象使用注解@......
  • Golang多线程打印ABC
    packagemainimport("fmt""sync")funcThreeG(){varch1,ch2,ch3=make(chanstruct{}),make(chanstruct{}),make(chanstruct{})varwgsync.WaitGroupwg.Add(3)gofunc(sstring){deferwg.Done......
  • 多线程系列(二十一) -ForkJoin使用详解
    一、摘要从JDK1.7开始，引入了一种新的Fork/Join线程池框架，它可以把一个大任务拆成多个小任务并行执行，最后汇总执行结果。比如当前要计算一个数组的和，最简单的办法就是用一个循环在一个线程中完成，但是当数组特别大的时候，这种执行效率比较差，例如下面的示例代码。longsum=0......
  • 07.多线程的概述
    1.线程的概述进程--是我们程序的执行实例，进程在执行的时候，真正执行的就是进程中的线程，进程只是提供了线程执行的资源（PCB）。---进程包含线程进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。线程：......
  • Java面试题：假设你正在开发一个Java后端服务，该服务需要处理高并发的用户请求，并且对内存
    Java内存优化、线程安全与并发框架：综合面试题解析Java作为一种广泛使用的编程语言，其内存管理、多线程和并发处理是开发者必须掌握的核心技能。为了全面评估候选人在这些领域的知识水平和实际应用能力，我们设计了一道综合性的面试题。本文将对这道题目进行深入分析，从核心知识......
  • 【转载】Redis -- IO多路复用及redis6的多线程
    都知道redis是通过单线程+io多路复用来避免并发问题的，然后在redis6的时候redis引入了多线程，这里就来详细说说IO多路复用模型以及redis的多线程。Redis的I/O多路复用模型有效的解决单线程的服务端，使用不阻塞方式处理多个client端请求问题。在看I/O多路复用知识之前，我们先来......
  • 多线程
    1. 程序、进程与线程程序(program)：        为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。进程(process)：        程序的一次执行过程，或是正在内存中运行的应用程序。如:运行中的QQ，运行中的网易音乐播放器。每个进程都有......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99