linux之多线程

最新推荐文章于 2024-09-14 11:45:11 发布
最新推荐文章于 2024-09-14 11:45:11 发布
阅读量210 收藏
点赞数
分类专栏： linux 并发编程 操作系统 文章标签： linux c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjfdsklfdkfksd/article/details/130702140
版权

1.基础知识

查看线程：ps -xH|grep 进程名 ；
查看进程：ps -ef |grep 进程名

不能在子线程中使用exit，否则整个进程会退出，，一般使用pthread_exit(0)；

2. 线程参数的传递

	//这种方式的强制转换在线程传参的时候很多
	int ii = 10;
	void* ptr = (void*)(long long)ii;

	int jj = (int)(long long)ptr;

线程参数传递一般使用值传递，也就是使用上面的这样强制类型转换，将值(不是地址)强制转换为void *类型，注意上面的强制类型转换并没有传入地址，传入地址的方式仍然是共享变量的传入参数。

#include<stdio.h>
#include <pthread.h>
#include <unistd.h>
void* handler1(void* arg);
void* handler2(void* arg);
void* handler3(void* arg);
void* handler4(void* arg);
void* handler5(void* arg);

long var=0;

int main()
 {
    pthread_t pthid1,pthid2,pthid3,pthid4,pthid5;
    if(pthread_create(&pthid1,NULL,handler1,(void*)var)!=0)//这样传参数是值传递
    {
        printf("创建线程pthid1失败\n");
        return -1;
    }
  var++;
  if(pthread_create(&pthid2,NULL,handler2,(void*)var)!=0)
  {
    printf("创建线程pthid2失败\n");
    return -1;
  }
  var++;
  if(pthread_create(&pthid3,NULL,handler3,(void*)var)!=0)
  {
    printf("创建线程pthid3失败\n");
    return -1;
  }
  var++;
  if(pthread_create(&pthid4,NULL,handler4,(void*)var)!=0)
  {
    printf("创建线程pthid4失败\n");
    return -1;
  }
  var++;
  if(pthread_create(&pthid5,NULL,handler5,(void*)var)!=0)
  {
    printf("创建线程pthid5失败\n");
    return -1;
  }
   printf("pthid1=%lu,pthid2=%lu,pthid3=%lu,pthid4=%lu,pthid5=%lu\n",pthid1,pthid2,pthid3,pthid4,pthid5);
   printf("等待子线程退出\n");
   //pthread_join会使主进程阻塞在这里，用于调试
   pthread_join(pthid1,NULL);
   printf("子线程1已退出\n");
   pthread_join(pthid2,NULL);
   printf("子线程2已退出\n");
   pthread_join(pthid3,NULL);
   printf("子线程3已退出\n");
   pthread_join(pthid4,NULL);
   printf("子线程4已退出\n");
   pthread_join(pthid5,NULL);
   printf("子线程5已退出\n");
   return 0;
}
void* handler1(void* arg)
{
    printf("handler1 var = %d\n", (int)(long)arg);
    for(int i=0;i<5;i++)
    {
       sleep(1);
       printf("handler1 sleep 1sec ok,%d\n",(int)(long)arg);
    }
   //子线程退出
   pthread_exit(0);
}
void* handler2(void* arg)
{
      printf("handler2 var = %d\n", (int)(long)arg);
    for(int i=0;i<5;i++)
    {
       sleep(1);
       printf("handler2 sleep 1sec ok,%d\n",(int)(long)arg);
    }
   pthread_exit(0);
}
void* handler3(void* arg)
{
       printf("handler3 var = %d\n", (int)(long)arg);
    for(int i=0;i<5;i++)
    {
       sleep(1);
       printf("handler3 sleep 1sec ok,%d\n",(int)(long)arg);
    }
   pthread_exit(0);
}
void* handler4(void* arg)
{
    printf("handler4 var = %d\n", (int)(long)arg);
    for(int i=0;i<5;i++)
    {
       sleep(1);
       printf("handler4 sleep 1sec ok,%d\n",(int)(long)arg);
    }
   pthread_exit(0);
}
void* handler5(void* arg)
{
    printf("handler5 var = %d\n", (int)(long)arg);
    for(int i=0;i<5;i++)
    {
       sleep(1);
       printf("handler5 sleep 1sec ok,%d\n",(int)(long)arg);
    }
   pthread_exit(0);
}

3. 线程资源的回收

3.1 线程的状态

线程有两种状态：joinable,unjoinable
joinable:当子线程终止时，不会释放线程所占用的资源，这种线程称为僵尸线程, 创建线程时线程的默认属性为joinable。

3.2 正确回收线程资源色四种方式

  1. 创建线程 后，调用pthread_join等待线程退出，一般不会采用这种方法，因为pthread_join会阻塞

       pthread_join(pthid, NULL)

  2. 创建线程前，调用pthread_attr_setdetachstate将线程设为detached,这样线程退出时，系统自动回收线程资源

     pthread_t  pthid;   
 pthread_attr_t attr;  
 
 pthread_attr_init(&attr);  
 pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);  // 设置线程的属性
 pthread_create(&pthid, &attr, handler1, NULL);

  3. 创建线程后，在创建线程的程序中调用pthread_detach，将新创建的线程设置为detached状态

    pthread_detach(pthid)

  4. 在线程函数中调用pthread_detach改变自己的状态

    pthread_detach(pthread_self())

4. 线程的返回状态

int pthread_join(pthread_t thread, void **retval);

通过参数retval接受线程的返回值，具体自己设计返回值，根据返回值来做业务逻辑。

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

void* handler(void* arg);

int var=0;
/*
int pthread_create(
    pthread_t *thread, 
    const pthread_attr_t *attr, 
    void *(*start_routine) (void *), 
    void *arg
);
RETURN VALUE
    On success, pthread_create() returns 0; on error, it returns an error number,
    and the contents of *thread are undefined.
*/

int main()
{
    pthread_t pthid;
    if(pthread_create(&pthid, NULL, handler, NULL)!=0)
    {
        printf("创建线程pthid1失败\n");
        return -1;
    }
    printf("pthid=%lu\n",pthid);
    printf("等待子线程退出\n");
    //pthread_join会使主进程阻塞在这里，用于调试
    int ret;//获取线程返回值
    int result = pthread_join(pthid, (void**)&ret);
    printf("子线程1已退出(result=%d,ret=%d)\n", result, ret);
    return 0;
}

void* handler(void* arg)
{


    //下面这两种方式都可以返回线程的值
    return (void*)10;
    //pthread_exit(10);
}

5. 线程取消

5.1 线程取消

  1. 子线程被取消后，在主线程中调用pthread_join,得到线程的返回状态是-1, PTHREAD_CANCELED
  2. 子线程可以调用
int pthread_setcancelstate(int state, int *oldstate);

其中state有两种状态：
PTHREAD_CANCEL_ENABLE（缺省情况）
PTHREAD_CANCEL_DISABLE
设置对pthread_cancel请求的响应方式

  1. 取消类型有两种：延迟取消，立即取消
int pthread_setcanceltype(int type, int *oldtype);

PTHREAD_CANCEL_DEFERRED （默认参数, 延迟到取消点取消）
PTHREAD_CANCEL_ASYNCHRONOUS（立即取消）

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

void* handler(void* arg);

int var=0;

int main()
 {
    pthread_t pthid;
    if(pthread_create(&pthid, NULL, handler, NULL)!=0)
    {
        printf("创建线程pthid失败\n");
        return -1;
    }
   usleep(2);
   //取消线程
   pthread_cancel(pthid); 
   printf("pthid = %lu\n", pthid);
   printf("等待子线程退出\n");
   //pthread_join会使主进程阻塞在这里，用于调试
   int ret;
   int result = pthread_join(pthid, (void**)&ret);
   printf("子线程1已退出(result=%d,ret=%d)\n", result, ret);
   return 0;
}

void* handler(void* arg)
{
    //pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    //pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
    //pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    int jj=0;
    for(int i=0;i<5000000;i++)
    {
       jj++;
       jj--;
       jj++;
       //sleep(1);//sleep函数是一个取消点，线程运行到这会取消
       ++var;
        //设置取消点
        pthread_testcancel();
        //printf("handler1 sleep 1sec ok,%d\n",var);
    }
    printf("jj=%d\n",jj);
   
    //子线程退出
    pthread_exit(0);
}

5.2 应用场景

应用于总线程获取多个线程的状态，一旦某个线程挂掉，总线程即cancel子线程

6. 线程清理函数

6.1 概述

线程清理函数（thread cleanup function）是在线程退出时自动调用的函数。它可以用来清理线程中使用的资源，例如释放动态分配的内存、关闭文件句柄等。

线程清理函数通过pthread_cleanup_push()和pthread_cleanup_pop()函数来注册。pthread_cleanup_push()函数用于注册一个线程清理函数，它将该函数压入线程的清理函数栈中。pthread_cleanup_pop()函数则用于弹出该函数，从而使得该函数不再被调用。

6.2

  1. void pthread_cleanup_pop(int execute);当execute=0时，清理函数不被执行，execute=1清理函数被执行；
  2. 当执行pthread_exit（0）,也会弹出清理函数，并且执行它；
  3. 线程被取消时，所有注册的清理函数被调用；
#include<stdio.h>
#include <pthread.h>
#include <unistd.h>
void* handler(void* arg);

int var=0;

void cleanfun1(void*);
void cleanfun2(void*);
void cleanfun3(void*);
int main()
 { 
   pthread_t pthid1;
   if(pthread_create(&pthid1,NULL,handler,NULL)!=0)
  { 
    printf("创建线程pthid1失败\n");
    return -1;
  }
   printf("等待子线程退出\n");
   //pthread_join会使主进程阻塞在这里，用于调试
   sleep(2);
  // pthread_cancel(pthid1);
   int ret;
   int result=pthread_join(pthid1,(void** )&ret);
   printf("子线程已退出(result=%d,ret=%d)\n",result,ret);
   return 0;
}
void* handler(void* arg)
{
    // 注册线程清理函数
    int socketid=10;
    pthread_cleanup_push(cleanfun1,(void*)(long)socketid);
    pthread_cleanup_push(cleanfun2,NULL);
    pthread_cleanup_push(cleanfun3,NULL);
    for(int i=0;i<3;i++)
    {
        sleep(1);
        printf("sleep %dsec ok.\n",i+1);return 0;
    }
   
    pthread_cleanup_pop(1);//0不执行清理函数
    pthread_cleanup_pop(1);
    pthread_cleanup_pop(1);
    pthread_exit(0);//退出时执行线程清理函数
}
void cleanfun1(void* arg )
{
  printf("fun1 is ok,arg=%d\n",(int)(long)arg);
}
void cleanfun2(void*)
{
  printf("fun2 is ok\n");
}
void cleanfun3(void*)
{
  printf("fun3 is ok\n");
}

7. 线程信号

  1. 从外部向进程发送信号时，信号到达进程，不会中断子线程的执行
  2. 信号不会中断系统调用，例如sacnaf阻塞，仍然会阻塞到这里
  3. 捕获信号的代码放到哪里都一样，一般都放到进程的主函数中

8. 多线程版本的socket通信

server

#include "_freecplus.h"
#include <vector>
#include <pthread.h>
#include <signal.h>

void sig2or5Slot(int sig);
void threadCleanup(void* arg);
void* threadTask(void* arg);

std::vector<pthread_t>   vecThreadId;

CLogFile logfile;
CTcpServer TcpServer;   // 创建服务端对象

int main(int argc, char* argv[])
{
    signal(2, sig2or5Slot); 
    signal(5, sig2or5Slot);
    logfile.Open("mul.log", "a+");
    if (TcpServer.InitServer(5005) == false) // 初始化TcpServer的通信端口。
    {
        printf("TcpServer.InitServer(5858) failed.\n");
         return -1;
    }

    while (true)
    {
        if (TcpServer.Accept() == false)   // 等待客户端连接。
        {
            printf("TcpServer.Accept() failed.\n"); return -1;
        }
        printf("客户端(%s)已连接。\n", TcpServer.GetIP());
        pthread_t pthid;
        if (pthread_create(&pthid, NULL, threadTask, (void*)(long)TcpServer.m_connfd) != 0)
        {
            printf("creat pthid fail\n");
            return -1;
        }
        vecThreadId.push_back(pthid);
    }
    return 0;
}

//2,15信号处理函数
void sig2or5Slot(int sig)
{
    printf("sig2or5Slot begin.\n");
    TcpServer.CloseListen();//关闭监听的socket
    for (int i = 0; i < vecThreadId.size(); i++)
    {
        printf("cancel %ld\n", vecThreadId[i]);
        pthread_cancel(vecThreadId[i]);//取消全部的线程,回调用线程清理函数
    }
    printf("sig2or5Slot end.\n");
    usleep(20);
    exit(0);
}

//设置线程清理函数
void threadCleanup(void* arg)
{
    printf("线程清理函数开始。\n");
    close((int)(long)arg);//关闭线程连接的socket 
    for (int i = 0; i < vecThreadId.size(); i++)
    {
        if (vecThreadId[i] == pthread_self())
        {
            vecThreadId.erase(vecThreadId.begin() + i);
        }
    }
    printf("线程清理函数结束.\n");
}

void* threadTask(void* arg)
{
    pthread_cleanup_push(threadCleanup, arg);//注册线程清理函数
    pthread_detach(pthread_self());         //分离线程
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);//设置取消方式为立即取消
    int sockfd = (int)(long)(arg);

    while (true)
    {
        char strbuffer[1024];  // 存放数据的缓冲区。
        int buflen = 0;
        memset(strbuffer, 0, sizeof(strbuffer));
        if (TcpRead(sockfd, strbuffer, &buflen, 300) == false) break; // 接收客户端发过来的请求报文。
        printf("接收：%s\n", strbuffer);
        logfile.Write("接收：%s\n", strbuffer);
        strcat(strbuffer, "ok");      // 在客户端的报文后加上"ok"。
        printf("发送：%s\n", strbuffer);
        if (TcpWrite(sockfd, strbuffer, buflen) == false) break;     // 向客户端回应报文。
    }

    printf("客户端已断开。\n");
    pthread_cleanup_pop(1);//执行线程清理函数
}

client

/*
 *  程序名：demo47.cpp，此程序演示采用freecplus框架的CTcpClient类实现socket通信的客户端。
 *  作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include "_freecplus.h"
 
int main(int argc,char *argv[])
{
  if (argc!=3)
  {
    printf("Using:./demo47 ip port\nExample:./demo47 172.21.0.3 5005\n\n"); return -1;
  }

  CTcpClient TcpClient;   // 创建客户端的对象。
 
  if (TcpClient.ConnectToServer(argv[1],atoi(argv[2]))==false) // 向服务端发起连接请求。
  {
    printf("TcpClient.ConnectToServer(\"%s\",%s) failed.\n",argv[1],argv[2]); return -1;
  }
  
  char strbuffer[1024];    // 存放数据的缓冲区。
 
  for (int ii=0; ii<5; ii++)   // 利用循环，与服务端进行5次交互。
  {
    memset(strbuffer,0,sizeof(strbuffer));
    snprintf(strbuffer,50,"%d:this is %d supergirl,id:%03d.",getpid(),ii+1,ii+1);
    printf("receve:%s\n",strbuffer);
    if (TcpClient.Write(strbuffer)==false) break;    // 向服务端发送请求报文。
 
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpClient.Read(strbuffer,20)==false) break;  // 接收服务端的回应报文。
    printf("receve:%s\n",strbuffer);
 
    sleep(5);
  }
 
  // 程序直接退出，析构函数会释放资源。
}
wjfdsklfdkfksd
关注
专栏目录
Linux多线程
GG_Bruse的博客
02-13 8446
之前提到每个线程都有独占的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计管理模块，而是直接复用了进程控制块，即Linux中的所有执行流都是轻量级进程。Linux系统中不提供真正的线程ID，只提供LWP，即操作系统只需通过LWP对轻量级进程进行管理，而供用户使用的线程接口等其他数据，由线程库来管理，因此管理线程时的"先描述，再组织"就应该在线程库中完成。
Linux 多线程原理深剖
热门推荐
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
linux多线程
weixin_46485873的博客
07-09 3098
多线程：所有程序并发运行，多条路径可以同时执行 多线程包括：理解线程并发、线程同步方法、线程安全概念 线程指：进程内部得一条执行路径（从主函数的第一行代码到最后一行）主线程：main 子线程：线程函数 比如：fun.... 进程指：一个正在运行的程序 在linux平台创建线程，是内核提供的头文件#include注意编译的时候要加 -lpthreadpthread_create(线程id，默认的属性可以不设置为NULLL，参数函数); 创建线程子线程如下图 有些时候主线......
Linux多线程编程
C_Trip的博客
11-19 3722
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
Linux多线程——概念
weixin_57023347的博客
09-22 1721
前言 Linux系统中并没有真正意义上的多线程，因为linux内核中并没有为线程构建数据结构。它的线程使用进程来模拟的。 一.线程的概念 1.1 什么是线程 现在再理解进程：进程是承担分配系统资源的基本实体 线程是进程里的一个执行流，CPU调度的基本单位是线程。就比如上图的一个tast_struct就是一个线程。它们共用一个进程地址空间。一个进程可以有一个或者多个执行流。 由于在Linux中没有真正意义上的线程，...
Linux之线程
hello
02-25 2062
和多进程相比，多线程是一种比较节省资源的多任务操作方式。启动一个新的进程必须分配给它独立的地址空间，每个进程都有自己的堆栈段和数据段，系统开销比较高，进行数据的传递只能通过进行间通信的方式进行。在同一个进程中，可以运行多个线程，运行于同一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享全局变量和对象，启动一个线程所消耗的资源比启动一个进程所消耗的资源要少。.........
【Linux】多线程操作
m0_72563041的博客
05-28 1388
多线程操作
Linux —— 多线程
M的博客
08-05 5987
目录一、线程的概念1.理解线程 2.线程的优点3.线程的缺点 4.线程异常5.线程用途二、Linux进程VS线程 1.进程和线程2.进程的多个线程共享3.进程和线程的关系三、Linux线程控制1.POIX线程库2.线程创建3.线程等待4.线程终止5.分离线程6.线程ID及进程地址空间布局 如何理解之前的进程？CPU如何看待task_struct？Linux下并不存在真正的线程？而是用进程模拟的？......
linux——多线程，线程控制
qq_63943454的博客
10-10 1901
线程控制，对线程的创建，退出，等待，分离的操作，后续还有，同步，互斥，等控制。以达到对线程更好的管理和利用。
Linux 使用 Python 执行多线程命令
blainet的博客
04-20 3062
参考链接1：https://blog.csdn.net/qq_27825451/article/details/102909772 参考链接2：https://www.cnblogs.com/sunshine-blog/p/12027606.html 参考链接3：https://www.liaoxuefeng.com/wiki/1016959663602400/1017629247922688 参考链接4：https://blog.csdn.net/liuyanfeier/article/details/.
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
"linux_code.rar"这个压缩包包含了一些关于Linux多线程编程的源码示例，这对于初学者来说是一份宝贵的教育资源。 1. **线程概念**： 线程是操作系统分配处理器时间的基本单元，它是程序中的执行流。与进程相比，...
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
Linux c++多线程串口编程demo
01-26
本示例"Linux c++多线程串口编程demo"聚焦于利用多线程技术实现串口通信，这是一种常见的硬件接口，用于设备之间的数据交换。下面我们将深入探讨这个demo涉及的知识点。 1. **多线程编程**：在C++中，我们可以使用`...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
【Linux】：信号与信号产生
Yikefore的博客
09-12 964
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
【Linux】ldd常见问题
zclinux的博客
09-11 1056
当你自己编译程序时，可以通过。
Linux如何使用sed命令进行文本替换
yang295242361的博客
09-12 543
在Linux中，sed（Stream Editor）是一个用于处理文本流的命令行工具，它非常适合用于执行基本的文本转换。sed可以读取输入的文本文件，根据指定的指令对文本进行处理，并将结果输出到标准输出设备。
Java wrapperr打包springboot项目到linux和Windows
最新发布
欢迎查阅
09-14 996
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值