linux线程

最新推荐文章于 2024-05-01 11:39:03 发布
最新推荐文章于 2024-05-01 11:39:03 发布
阅读量177 收藏 1
点赞数
分类专栏： linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012850999/article/details/79533691
版权
1、线程概念
线程可以看做是一个正在运行的函数，一个进程中至少有一个函数运行，那么也就是说一个进程至少有一个线程
在函数中创建出来的线程，彼此之间是兄弟关系

posix线程是一套标准，而不是一套实现

线程的标识：
pthread_t

ps axm：查看线程信息

pthread_equal(tid1,tid2)：比较两个线程标识，相同返回非0值，不相同返回0值

调用线程函数需要加上链接选项 -l pthread
可以指定一个makefile
LDFLAGS+=-pthread

pthread_self()：返回当前线程的标识


2、线程的创建
pthread_create(&tid,属性，函数指针，函数参数)：在当前的进程中创建一个新的线程，成功返回0，失败返回errno值
&tid：回填一个线程标识符
属性：写NULL取默认属性
函数指针：创建线程就等于要同时再跑一个兄弟函数
函数参数：兄弟线程函数需要的参数

线程的调用取决于调度器的策略线程传参：




3、线程的终止
3种方式： 1.线程从启动例程返回
2.线程可以被同一进程中的其他线程取消
3.线程调用pthread_exit()函数

pthread_exit(函数返回值)：线程结束，并带回一个值，没有就写NULL

线程的取消：
pthread_cancel(要取消的线程);

4、线程的收尸
pthread_join(tid，回填线程的返回值)：给一个进程收尸，并带回pthread_exit函数的参数返回值

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
void *fun(void *s)
{
  int i=10;
  while(i)
    {
     printf("线程打开\n");
     i--;
    }


 pthread_exit(NULL);//线程退出，可以带出返回值
}


int main(void)
{
    pthread_t pid;


    int ret= pthread_create(&pid,NULL,fun,NULL);//创建一个线程，传入参数需要依靠（void *）做强转
    if(ret!=0)
    {
        strerror(ret);
        exit(1);
    }
    pthread_join(pid,NULL);//线程收尸可以接收返回值


}

5、线程同步：此操作目的在于解决线程存在的竞争问题
        sudo apt-get install manpages-posix-dev
互斥量：pthread_mutex_t mutex;
pthread_mutex_init(互斥量指针,互斥量指针属性)：初始化互斥量
属性：NULL为默认属性
使用宏初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_destroy(互斥量指针)：销毁互斥量

pthread_mutex_lock(互斥量指针)：申请锁，若锁可用，获得锁并加锁，若不可用，阻塞
pthread_mutex_unlock(互斥量指针)：解锁

池类算法
sched_yield():出让调度器

eg:计算质数不加互斥量
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<string.h>


#define MIN 30000000
#define MAX 30000200


#define PHMAX 3
static int num=0;


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;






void *fun(void *s)
{
    int i=0;
    
    while(1)
    {
int flag=1;
    if(num==-1)
    break;
while(num==0);


i=num;//接到数据先接受


num=0;//再将数据变为0 告诉主线程该仍数据了


for(int  j=2;j<i/2;j++)
{
if(i%j==0)
            {
flag=0;
break;
}
}
if(flag)
printf("%d\n",i);
}
 
//结束掉线程
 pthread_exit(NULL);
}




int main(void)
{
    pthread_t pid[PHMAX];
    int i=0;
  
//创建三个线程
    for( i=0;i<PHMAX;i++)
    {
    int ret= pthread_create(&pid[i],NULL,fun,NULL);
    if(ret!=0)
    {
        strerror(ret);
        exit(1);
    }
   }




   for(int j=MIN;j<MAX;j++)
   {
         while(num!=0);//子线程如果将num变为0，那么可以再给下一个数了，不然就死等
         num=j;
   }


   while(num!=0);
       num=-1;//数据仍完


//给线程收尸
   for(int m=0;m<PHMAX;m++)
        pthread_join(pid[m],NULL);
    exit(1);


}

计算结果：


线程出现竞争关系并且无法自己退出

eg:添加互斥量

/*************************************************************************
> File Name: ph.c
> Author: 
> Mail: 
> Created Time: 2017年10月29日 星期日 22时10分49秒
 ************************************************************************/


#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#include<sched.h>
#define MIN 30000000
#define MAX 30000500


pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//初始化我的互斥量


#define PHMAX 3
static int num=0;


void *fun(void *s)
{
    int i=0;
    
    while(1)
    {
     pthread_mutex_lock(&mutex);//如果线程强到资源那么我就把门锁上
int flag=1;
    if(num==-1)
        {
            pthread_mutex_unlock(&mutex);//如果是-1，那么我就解锁并且跳出循环
    break;
        }
while(num==0);


i=num;


num=0;
      pthread_mutex_unlock(&mutex);//我得到数据之后就把锁释放掉让别人去抢主线程的资源
        //然后做自己该干的主要事情
for(int  j=2;j<i/2;j++)
{
if(i%j==0){
flag=0;
break;
}
//printf("%d\n",i );
}
if(flag)
printf("%d\n",i);
}
 


 pthread_exit(NULL);
}




int main(void)
{
    pthread_t pid[PHMAX];
    int i=0;
  
    pthread_mutex_init(&mutex,NULL);//初始化互斥量
    for( i=0;i<PHMAX;i++)
    {


    int ret= pthread_create(&pid[i],NULL,fun,NULL);
    if(ret!=0)
    {
        strerror(ret);
        exit(1);
    }
   }






   for(int j=MIN;j<MAX;j++)
   {
      
    //printf("j:%d\n",j);
       // pthread_mutex_lock(&mutex);
      while(num!=0)//如果这里不等于0就说明我的东西没有被其他线程抢走，那我就等他们把数据抢走
      {
           //pthread_mutex_unlock(&mutex);
           //sched_yield();//出让调度器
          //pthread_mutex_lock(&mutex);
      }
         num=j;
       //pthread_mutex_unlock(&mutex);
   }


   while(num!=0);//我发的东西还没抢完，或者还没人搞事，
    //别人已经把最后的数据拿到了
    pthread_mutex_lock(&mutex);//我就枪锁关门  
      num=-1;//把数据变为-1，让其他线程都拿到
    pthread_mutex_unlock(&mutex);//解锁让孩儿们去强吃的


pthread_mutex_destroy(&mutex);//销毁掉我的互斥量
   for(int m=0;m<PHMAX;m++)
        pthread_join(pid[m],NULL);
    exit(1);


}

结果输出：


 条件变量：pthread_cond_t
            pthread_cond_init(条件变量指针，属性)：初始化条件变量
                属性：NULL为默认属性
            使用宏初始化：pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

            ptherad_cond_destroy(条件变量指针)：销毁条件变量

            pthread_cond_wait(条件变量指针，互斥量指针)：解锁等待通知，被唤醒后再申请锁

            pthread_cond_broadcast(条件变量指针)：唤醒所有的等待线程
            pthread_cond_signal(条件变量指针)：唤醒任意一个等待的线程

        改变通知法：

/*************************************************************************
> File Name: ph_mycopy.c
> Author: 
> Mail: 
> Created Time: 2017年10月30日 星期一 14时20分03秒
 ************************************************************************/


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


#define BUFSIZE 1024
#define THREADNUM 4//定义线程数量
#define FILESIZE  13331520
static int num=FILESIZE/THREADNUM;
static int th=0;




pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;




void *fun(void *s)
{
int sum;
   char buf[BUFSIZE];
   int res;
   int file,file2;
   int i=0;
   file=open("./tmp.mp3",O_WRONLY);
   file2=open("./s.mp3",O_RDONLY);


     
       pthread_mutex_lock(&mutex); //使用互斥量使得偏移量不回发生竞争关系
       i=th;
       
   th++;
       pthread_mutex_unlock(&mutex);
       
       lseek(file,num*i,SEEK_SET);
   lseek(file2,num*i,SEEK_SET);   
   
  
   
   while(1)
   {
      
        res=read(file2,buf,BUFSIZE);
    if((sum>(FILESIZE/THREADNUM))||res==0)
      {
     
      printf("I:%d,sum:%d:pthread_self:%u\n",i,sum,pthread_self() );
         break;
      }
  
   
     
      write(file,buf,res);
      sum+=res;
   }
  
  close(file);
  close(file2);
   
pthread_exit(NULL);
}






int main(int argc,char *argv[])
{   

FILE * file;
    pthread_t tid[THREADNUM];
    int i;
     pthread_mutex_init(&mutex,NULL);//条件变量


   file=fopen("./tmp.mp3","w");
   fseek(file,FILESIZE-1,SEEK_END);
   fwrite("\0",1,1,file); 
   fclose(file);
   for(i=0;i<THREADNUM;i++)
   {
      pthread_create(&tid[i],NULL,fun,NULL);//创建线程
   }


   for(int m=0;m<THREADNUM;m++)
        pthread_join(tid[m],NULL);


pthread_mutex_destroy(&mutex);
  exit(1);

}



Jehovah_W
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Linux】线程
DanteKing的博客
03-30 4757
Linux线程的基础知识
linux－线程
KHY666的博客
11-25 215
linux线程 - 线程的概念 １＞linux的线程与windos的线程区别很大（win的线程比较完善，进程不行，linux的进程发展的更早） ２＞每一个进程都会分配0-4G的虚拟空间地址，而线程共享0-4G的虚拟地址空间，但每一个线程有自己不同的pcb．但pcb中指向内存资源的三级页表是相同的 三级页表（mmu映射虚拟地址到物理内存的过程） ３＞线程是最小的执行单位（抢占cpu的最小单位（根据线程的LWP号（使用ps -Lf pid//查看指定的线程LWP号））），进程是最小的资源分配单位（0-4G资
【Linux】线程详解
m0_72940975的博客
07-15 1566
在一个程序里的一个执行路线就叫做线程。更准确的定义是：线程是“一个进程内部的控制序列”一切进程都至少有一个执行线程线程在进程内部运行，本质是在进程地址空间内运行在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更轻量化透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流进程的创建伴随着进程控制块，进程地址空间以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。
【Linux 系统】多线程（线程控制、线程互斥与同步、互斥量与条件变量）-- 详解
最新发布
Elena's Blog
05-01 1504
输出型参数，返回线程 ID。attr：设置线程的属性，attr为NULL表示使用默认属性。想让线程执行的任务，它是一个返回值 void*，参数 void* 的一个函数指针。回调函数的参数，若线程创建成功，在执行 start_routine 时，会把 arg 传入 start_routine。thread：线程ID。value_ptr：它指向一个指针，后者指向线程的返回值。调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止。
linux线程全解
小嵌同学的博客
09-02 2484
目录一、再论进程1、进程的挂起、阻塞和睡眠的区别：2、多进程实现同时读取键盘和鼠标 一、再论进程 1、进程的挂起、阻塞和睡眠的区别： https://www.cnblogs.com/ck1020/p/6669661.html 2、多进程实现同时读取键盘和鼠标 https://blog.csdn.net/u011508527/article/details/46878205 https://blog.csdn.net/jobbofhe/article/details/82192092 思路：创建子进程，然后父
【Linux系统】Linux多线程详解
fufufu_的博客
07-15 4289
由上图可以很好地理解线程为什么是CPU调度的基本单位，在CPU看来，它只关心一个独立的执行流，无论进程内部是一个还是多个执行流，CPU都是以task_struct为单位来调度的。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。在操作系统的的视角下，Linux下没有真正意义的线程，而是用进程模拟的线程（LWP，轻量级进程），所以Linux不会提供直接创建线程的系统调用，最多提供创建轻量级进程的接口。个字节，也就是1MB。
Linux线程
weixin_46107667的博客
06-22 239
Linux线程什么是线程 什么是线程 线程就是进程的一条执行流，是CPU的调度的基本单位，，这个执行流在Linux下是通过pcb实现的，共享了进程的大部分资源。相比进程更加轻量化，所以线程也被称为轻量级进程。线程在进程内部运行的，是进程内部的一个控制序列。 ...............
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
在Linux系统中，多线程编程是实现高效并发执行任务的一种常见方法。通过创建和管理多个线程，程序可以充分利用现代多核处理器的资源，提高软件的响应速度和整体性能。"linux_code.rar"这个压缩包包含了一些关于Linux...
Linux多线程编程小结
01-20
　Linux进程创建一个新线程时，线程将拥有自己的栈（由于线程有自己的局部变量），但与它的创建者共享全局变量、文件描写叙述符、信号句柄和当前文件夹状态。 　Linux通过fork创建子进程与创建线程之间是有差别的...
linux+linux多线程
11-23
linux+linux多线程 linux+linux多线程 linux+linux多线程
linux多线程教程.zip
01-22
linux多线程教程.zip
linux 线程
weixin_52637812的博客
02-17 211
什么是线程？在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”。一切进程至少都有一个执行线程。线程是进程内部的一条执行序列或执行路径，即一个可调度的实体。一个进程可以包含多条线程在Linux下进程是资源分配的基本单位，线程是cpu调度的基本单位1.1 线程的优点创建一个新线程的代价要比创建一个新进程小得多与进程之间的切换相比，线程之间的切换需要OS的工作量更少线程占用的资源比进程少得多。
Linux线程详解
热门推荐
小虾米编程
06-03 3万+
并行和并发的区别 1. 并发(concurrency)：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果--宏观上并行，针对单核处理器） 互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。 ...
Linux线程详解（概念、原理、实现方法、优缺点）
weixin_44602505的博客
12-08 1万+
文章目录一、Linux线程基本概念二、Linux内核线程实现原理三、创建线程四、线程的优缺点 一、Linux线程基本概念 linux中，线程又叫做轻量级进程（light-weight process LWP），也有PCB，创建线程使用的底层函数和进程底层一样，都是clone，但没有独立的地址空间；而进程有独立地址空间，拥有PCB。 Linux下：线程是最小的执行单位，调度的基本单位。进程是最小分配资源单位，可看成是只有一个线程的进程。 线程是一个进程内部的控制序列。控制序列可以理解为一个执行流。进程内部是指
linux 线程详解
Qurry的博客
01-11 930
进程有唯一的进程号PID，线程也不例外，也有唯一的ID号，线程ID不同于进程ID，它是只有在进程运行的时候才有意义。linux系统中，线程ID是一个无符号长整形数，可以通过函数获取线程ID。在shell终端编译链接的时候，由于pthread不在gcc默认的链接库中，需要在编译命令中使用-l选项指定链接库pthread，格式为：。
linux——线程
qq_47944751的博客
10-22 286
线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值