线程的应用

已于 2022-01-20 11:57:12 修改
阅读量331 收藏
点赞数 2
分类专栏： C++和C语言 计算机网络 文章标签： c语言 蓝桥杯 c++
于 2018-04-07 22:04:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuruhua/article/details/79845341
版权

线程的应用

一、线程的创建：

1.    代码

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<string.h>

#include<pthread.h>//p表示posix线程库

 

void*rout(void *arg)

{

 （void)arg;//解决编译器的警告（没有使用的参数），不想用这个参数。

  while(1){

    printf("I am thread\n");

    sleep(1);

  }

}

intmain(void)

{

   pthread_t tid;

   int ret;

  if((ret=pthread_create(&tid,NULL,rout,NULL)!=0)){

    fprintf(stderr,"pthread_create:%s\n",strerror(ret));

     exit(EXIT_FAILURE);

   }  

while(1){

    printf("I am main thread\n");

    sleep(1);

  }

return 0；

}

主线程里面创建了另外一个线程，运行之后，可以看到两个结果

发生错误：

：

2.    错误原因：需要加入命令：gcc Pthread.c -oPthread -l pthread

结果为：

 

查看线程的方式：

（1）ps

（2）pstack可以查看线程详细信息

（3）gdb也可以查看线程详细信息，讲gdb附加进程上（附加：把物理地址创建好，把虚拟地址空间和物理地址空间关联到一起gdb已经跑起来了，让gdb和进程关联到一起）：gdb attach pid即课把pid附加到进程上【info thread查看线程信息；bt查看主线程的调用栈；thread 数字：切换调用栈进行调试

二、线程终止：

1.    代码：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<string.h>

#include<pthread.h>

 

void*rout(void *arg)

{

  (void) arg;

  int count=0;

  while(1){

    ++count;

    if(count>=10)

    return;

    //pthred_exit(NULL);

    printf("I am thread\n");

    sleep(1);

  }

}

int main(void)

{

   pthread_t tid;

   int ret;

  if((ret=pthread_create(&tid,NULL,rout,NULL)!=0)){

   fprintf(stderr,"pthread_create:%s\n",strerror(ret));

     exit(EXIT_FAILURE);

   }

while(1){

    printf("I am main thread%lx\n\n",pthread_self());//打印当前线程的线程id

    sleep(1);

  }

}

//ctrl+s可能让打印的结果暂停；gdb attach

说明了线程执行的先后顺序是不确定的

法2

//void *rout(void *arg)

//{

 

// while(1){

//   printf("I am thread\n");

//   sleep(1);

//  }

//}

//int main()

//{

//  pthread_t tid;

//   int ret;

// if((ret=pthread_create(&tid,NULL,rout,NULL)!=0)){

//   fprintf(stderr,"pthread_create:%s\n",strerror(ret));

//     exit(EXIT_FAILURE);

//   }

//while(1){

//   ++count;

//   if(count>=10)

//   pthread_cancel(tid);

//    printf("I am mainthread %lx\n\n",pthread_self());

//    sleep(1);

//  }

//}

交替打印到一定次数后，调用pthread_cancel函数，把对应的线程终止掉。

 结果：

综上:非常不推荐使用pthread_cancel函数，另外一个线程执行到哪个位置是不确定的，若是正在修改bug，直接被终止，会导致程序出现错误。第一种：return最简单、直观。

三、进程等待

1.    代码

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<string.h>

#include<pthread.h>

 

void*rout(void *arg)

{

  int ret=100;

  int count=0;

  while(1){

    ++count;

    if(count>=10)

      return (void *)ret;//只要void*表示的内存范围可以涵盖int则是可行的

若是超过了void*能够表示的范围可以在堆上创建内存，从而得到一个指针

    printf("I am thread\n");

    sleep(1);

  }

}

intmain(void)

{

   pthread_t tid;

   pthread_create(&tid,NULL,rout,NULL);

   void *ret;

   pthread_join(tid,&ret);

   printf("ret=%d\n",(int)ret);

   return 0;

}

2.    结果

 

若是超过了void*能够表示的范围可以在堆上创建内存，从而得到一个指针:指针的大小是相同的

1、代码

typedef struct student{

int id;

int score;

int classno;

}student;

void*rout(void *arg)

{

(void)arg;

student* ret=(student*)malloc (sizeof(student));

ret->id=10;

ret->score=100;

ret->classno=30;

  int count=0;

  while(1){

    ++count;

    if(count>=10)

      return (void *)ret;//只要void*表示的内存范围可以涵盖int则是可行的

若是超过了void*能够表示的范围可以在堆上创建内存，从而得到一个指针；void*根据需要想要传什么就传什么，只告诉你地址，不告诉解析地址的方式；如何解析取决于构造时，按照什么样的方式进行构造。构造完成后，从主线程中拿到后进行强转，这个来回强转的过程必须保证方式是一样的。

构造数据时约定怎么解析，使用数据时就怎么解析；两者如果不匹配，就达不到想要的效果。

    printf("I am thread\n");

    sleep(1);

  }

}

intmain(void)

{

   pthread_t tid;

   pthread_create(&tid,NULL,rout,NULL);

   void *ret;

   pthread_join(tid,&ret);

student* st=(student*)ret;

   printf("ret=%d %d %d\n",st->id,st->score,st->classno);

   return 0;

}

四、进程分离

1.    代码

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<string.h>

#include<pthread.h>

 

void*rout(void *arg)

{

  int ret=100;

  int count=0;

  while(1){

    ++count;

    if(count>=10)

      return (void *)ret;

    printf("I am thread\n");

    sleep(1);

  }

}

intmain(void)

{

   pthread_t tid;

   pthread_create(&tid,NULL,rout,NULL);

  pthread_detach(tid);//通过主线程支持新线程进行分离

   while(1){

     printf("I am main%lx\n",pthread_self());

     sleep(1);

   }

   return 0;

}

2.    结果

 

五、线程共用同一虚拟地址空间：同一个线程共享所有的虚拟地址（栈，堆，全局变量，，，，）

1.、全局变量：

（1）代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

int g_count=0;//全局变量也可以在虚拟地址空间当中

void *rout(void *arg)

while（1）

{

 printf("I am main %lx,%d\n",pthread_self(),g_count);

   sleep(1);

}

int main()

{

  while(1){

    int  *ptr;

    ++count;

    printf("I am main %lx,%d\n",pthread_self(),g_count);

    sleep(1);

  }  

  }  

  return 0;

}

主线程循环一次，则count++；另外一个线程也可以感知到，说明共用同一块虚拟地址空间。

.2、局部变量（堆上）

（1）    代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

 

void *rout(void *arg)

{

int *ptr=(int*) arg;//传参时，把void*转换为int*；所以在入口函数中需要把int*用同样的规则转换为void*

while(1){

 printf("I am main %lx,%d\n",pthread_self(),*ptr);

   sleep(1);

}

}

int main()

{

  pthread_t tid;

  pthread_create(&tid,NULL,rout,（void*）ptr);

  int *ptr=(int *)malloc((sizeof(int)));

  *ptr=0;

  while(1){

    ++*ptr;//此时并不是++ptr，而是指向的变量的值

    printf("I am main %lx,%d\n",pthread_self(),*ptr);

    sleep(1);

   }

  return 0;

}

 

3.、栈上

（1）代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

int g_count=0;

void *rout(void *arg)

{

 printf("I am main %lx,%d\n",pthread_self(),g_count);

   sleep(1);

}

int main()

{

  int count=0;

  int *ptr=&count;   

  while(1){

    int  *ptr;

    ++count;

    printf("I am main %lx,%d\n",pthread_self(),g_count);

    sleep(1);

  }  

  return 0;

}

打印的结果可以没有立刻被执行而是在缓冲区中呆了一会儿返回值可能会跑到前面；

一方面体现了缓冲区的存在；另一方面体现了线程的执行次序是不确定的。第二次打印时，主线程还没修改完毕，只修改了一半，这又说明和进程之间的调度有关系。同个函数共享同一个线程可能会出现问题，执行顺序，及执行到那儿的问题。为了保证得到的结果正确，需要给要访问的对象加入一些同步互斥机制，保证线程安全。

六．线程异常终止：任何一个线程出现问题都会导致整个进程出现错误。

1代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

int g_count=0;

void *rout(void *arg)

{

 printf("I am main %lx,%d\n",pthread_self(),g_count);

int*p=NULL;

 p=100;//解引用空指针：进程会通过虚拟地址到物理地址的映射，映射过程中会发现这是一个空指针，是一个非法的地址。MM U会通知内核，内核会发送一个11号信号使进程异常终止。

   sleep(1);

}

int main()

{

  int count=0;

  int *ptr=&count;   

  while(1){

    int  *ptr;

    ++count;

     printf("I am main%lx,%d\n",pthread_self(),g_count);

   sleep(1);

   }

  return 0;

}

结果会产生段错误，主线程也不会打印：说明任何一个线程出现问题都会导致整个进程出现错误。使代码对稳定性的要求更高。

七．如何利用多线程利用多核cpu资源：线程不是越多越好，应与cpu内核数匹配。

查看cpu信息：cat proc cpu

每个cpu都有一个编号，每个cpu有两个核：现在的电脑存在逻辑核数的概念和物理核数的概念。虽然只有一个cpu，但是可以模拟出两个逻辑核心。

1.某一个CPU满

1）代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

 

void *rout(void *arg)

{

 printf("I am main %lx\n",pthread_self());

   sleep(1);

}

int main()

{

 while(1){

   ;  

  }

 return 0;

}

通过指令top可以查看thread进程，查看cpu占有率，发现只是吃满了cpu中 的一个（cpu%为100%）

2.2个cpu被占满

（1）代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

 

void *rout(void *arg)

{

（void）arg；

 while(1)

  {

   ;  

  }

}

int main()

{

 pthread_t tid;

 pthread_create(&tid,NULL,rout,NULL);

 pthread_detach(tid);

 while(1)

  {

   ;  

  }

 return 0;

}

此时查看cpu占有率发现为200%，说明吃满了2个cpu：虽然while没有做任何运算，只要代码里面做cpu计算都会一行一行的占用cpu代码。这些都属于cpu运行操作。Windows下不论有几个核，都不能存在200%，这种情况只在Linux下出现。【总共有8个核，极限条件下可能吃到800%】

3.4个进程

（1）代码

# include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

 

void *rout(void *arg)

{

 while(1){

   ;  

  }

}

int main()

{

 const int size=4;

 pthread_t tid[size];

  int i=0;

 for(;i<size;++i)

 {  

 pthread_create(&tid[i]，NULL,rout,NULL);

  }

 for(;i<size;++i){

   pthread_join(tid[i],NULL);

  }

 return 0;

}

（2）结果

 cpu吃到了400%

若是线程数超过总的cpu数，无论有多少线程，cpu个数是有限的，最多吃到cpu个数个就是其极限。说明线程不是越多越好，应该和cpu核数匹配。

.4.创建一个大的数组，完成操作：数组每个元素求平方值，结果放到对应的元素位上

//1 3 4 7

//1 9 16 49

（1）    使用单线程的情况：//如果是单个线程，先遍历，再一个一个的去求

 #include<stdio.h>

# include<stdlib.h>

# include<unistd.h>

# include<string.h>

# include<pthread.h>

# include<malloc.h>

获取时间戳函数：以1970年0时0分1秒为基准，计算到现在的时间
int64_t TimeStamp()//int64_t ：64位的有符号整数
{
 struct timeval tv; 
 gettimeofday(&tv,NULL);//第一个参数是一个结构体，包含当前函数秒级的时间戳和微秒级的时间戳
 return tv.tv_sec*1000*1000+tv.tv_usec;//把秒数转化为微秒，得到当前时刻的时间
}
typedef struct Context{
  int *ptr;
  size_t beg;//要计算的数组的其实位置
  size_t end;//要计算的数组的结束位置
}Context;//定义上下文信息
void *rout(void *arg)
{
 Context *context=(Context *)arg;
 size_t i=context->beg;
 for(;i<context->end;++i){
   context->ptr[i]=context->ptr[i]*context->ptr[i];
  }
return NULL;
}

int main()
{
//一个比较大的数组，我们想完成这样的操作，把数组中的每一个元素
//都给你求一个平方的值，把这个结果放到对应的元素位置上
 const size_t MAX_SIZE=10*1000*1000;
  int *ptr=(int *)malloc(MAX_SIZE*sizeof(int));
 
 const int size=1;
 pthread_t tid[size];
 int i=0;
 int64_t beg=TimeStamp();
 for(;i<size;++i){
 Context *context=(Context *)malloc(sizeof(context));
 context->ptr=ptr;
 context->beg=0;
 context->end=MAX_SIZE;
 pthread_create(&tid[i],NULL,rout,(void *)context);
  }
 for(;i<size;++i){
   pthread_join(tid[i],NULL);//返回则说明线程执行结束
  }
 int64_t end=TimeStamp();
printf(“time=%ld\n”,end-beg)；
 return 0;
}

（2）   2个线程，每个线程只占一半的区间，每个线程只计算其对应的去间

int64_t TimeStamp()
{
 struct timeval tv; 
 gettimeofday(&tv,NULL);
 return tv.tv_sec*1000*1000+tv.tv_usec;
}
typedef struct Context{
  int *ptr;
  size_t beg;//要计算的数组的其实位置
  size_t end;//要计算的数组的结束位置
}Context;//定义上下文信息
void *rout(void *arg)
{
 Context *context=(Context *)arg;
 size_t i=context->beg;
 for(;i<context->end;++i){
   context->ptr[i]=context->ptr[i]*context->ptr[i];
  }
}
int main()
{
 const size_t MAX_SIZE=10*1000*1000;
  int*ptr=(int *)malloc(MAX_SIZE*sizeof(int));
 
 const int size=2;
 pthread_t tid[size];
  inti=0;
 int64_t beg=TimeStamp();
 size_t offset_beg=0;
 size_t len=MAX_SIZE/size;//每个线程应该承载的数量
 for(;i<size;++i){
 Context *context=(Context *)malloc(sizeof(context));
 context->ptr=ptr;
 context->beg=offset_beg;
 offset_beg+=len;
 pthread_create(&tid[i],NULL,rout,(void *)context);
  }
 for(;i<size;++i){
   pthread_join(tid[i],NULL);
  }
 int64_t end=TimeStamp();
 return 0;
}

 创建两个线程的执行时间比创建一个线程时间差不多少了一半，之所以不是严格意义上的一半是因为，线程创建和返回也是有时间开销的；线程也是会不停的调度的，其他线程也想调度干活，所以差不多为一半，而不是严格意义上的一半。

说明线程可以提升程序的运行效率。

继续加大线程，不会是几乎减小一半的时间，而是减小的时间很少，因为线程调度的开销也会有额外 的影响。

xuruhua
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
鱼刺类_多线程应用v5.4模块
06-07
鱼刺类_多线程应用 - 更新日志。5.4.3(2017-12-01)。*修改 去除所有用到取启动时间的函数/方法 (修正在系统开机超过29天的机器上可能会出现问题)。*修正 类回调_生成 部分系统配置兼容问题。5.4.2(2017-11-21)。*...
线程应用（线程池）
AllenSquirrel
04-27 1585
线程池： 创建一堆工作线程（有最大数量限制），以及一个线程安全的队列，这些工作线程不断从任务队列取出任务进行处理 优点： 避免资源无限制使用所造成的资源耗尽的风险 避免频繁创建大量线程与销毁所带来的时间成本 实现： 直接在线程入口函数中定义好各种不同类型的处理方法 要处理什么数据，以及数据如何处理由外部传入 ...
并发编程笔记之线程的应用（一）
boyAndGirl_1的博客
08-21 212
如何应用多线程? 在java中，我们有有多种方式来实现多线程。如继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现带有返回值的多线程。 继承Thread类创建线程 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()是一个...
线程池实例
liguoxiangzhizui的博客
09-11 298
public Executor asyncServiceExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); //配置核心线程数 executor.setCorePoolSize(10); //配置最大线程数 executor.setMaxPoolSize(80); //配置队列大小 executor.setQueueCapacity(1000); //配置线程池中的线程的名称前缀 executor.setT
易语言-鱼刺类_多线程应用v5.4模块
06-29
鱼刺类_多线程应用 - 更新日志 5.4.3(2017-12-01) *修改 去除所有用到取启动时间的函数/方法 (修正在系统开机超过29天的机器上可能会出现问题) *修正 类回调_生成 部分系统配置兼容问题 5.4.2(2017-11-21) *增加 _取...
多线程应用
03-17
多线程的应用，采用C++编程实现两个不同进程的实现
线程的基本使用
m0_50127633的博客
11-20 390
文章目录线程的概念 线程的概念 线程，可简单理解为是程序执行的一条分支，也就是程序执行流的最小单元。线程是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同一进程的其他线程共享进程所拥有的全部资源。 主线程： 当一个程序启动时，就只有一个进程被操作系统创建，与此同时一个线程也立刻运行，该线程通常叫做线程的主程序，简而言之：程序启动就会创建一个主线程. 主线程的重要i性有两方面: 1）是产生其他子线程的线程 2）通常它必须最后完成执行比如执行各种关闭操作
线程应用实例
xingyu19911016的博客
08-16 531
线程简介 什么是线程 现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统就会创建一个Java进程。现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局 部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉 到这些线程在同时执行。 一个Java程序从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上**J
线程的简单运用
qq1925346284的博客
09-11 324
先来介绍一些基本概念。 程序：存储在磁盘上的一些指令。 进程：在内存中，程序运行起来后在操作系统中形成的一个进程。进程在运行的时候会向操作系统提供请求，请求硬件资源。进程会管理所有的 线程： 多线程 ...
多线程的应用
m0_56056482的博客
06-16 821
线程的简单应用
线程的使用
weixin_48656058的博客
12-01 4283
线程 首先要了解进程和线程的区别: 进程是唯一的,一个进程可以开启多个线程。 比如:你的电脑开机了,你任务管理器里面运行的程序就是线程 1.线程的生命周期有五种状态: 创建、就绪、运行、阻塞、死亡 1.1 创建(创建方式往下找): 创建一个线程,线程进入创建状态。 1.2 就绪: start()方法用于使一个线程进入就绪状态。 1.3 运行: 执行run()方法使线程进入运行状态 1.4 阻塞: wait(等待)会让线程进入阻塞状态,会失去所占用的资源; 还有其他方式可以让一
Java多线程的应用场景和应用目的举例
热门推荐
Java团长
04-01 2万+
点击上方“Java团长”，选择“置顶公众号”干货文章第一时间送达！通俗的解释一下多线程先：多线程用于堆积处理，就像一个大土堆，一个推土机很慢，那么10个推土机一起来处理，当然速度就快了，不过由于位置的限制，如果20个推土机，那么推土机之间会产生相互的避让，相互摩擦，相互拥挤，反而不如10个处理的好，所以，多线程处理，线程数要开的恰当，就可以提高效率。多线程使用的目的：1、吞吐量：做WEB，容器帮你
java多线程高级应用
韩小文的博客
03-02 1797
1.线程概念 java所谓多线程，顾名思义，就是多道线程执行线索，那么为什么要多线程呢？如果你的部分代码在执行某个i/o操作而受阻，那么程序的其他部分也不能执行，这样就严重的浪费了cpu，多线程机制就是为解决这个问题。 多进程并行执行时，在cpu上执行的某个进程因为等待某种资源而受阻时，多任务操作系统可以使进程挂起，而根据FIFO原则，时间片轮转等启动另一个不同的进程执行，直到前一进程获得
线程的一些基本使用方法
weixin_48788281的博客
10-28 1690
一 线程 1.1 线程基本概念 基本概念：程序、进程、线程 程序(program)是为完成特定任务,用某种语言编写的一组指令的集合,即指一 段静态的代码，静态对象 进程(process)是程序的一次执行过程,或是正在运行的一个程序,是一个动态的过程:有它自身的产生,存在和消亡的过程——生命周期 1如:运行中的QQ,运行中的MP3播放器 2程序是静态的,进程是动态的 3进程作为资源分配的单位,系统在运行时会为每...
java多线程的简单应用
田重阳的博客
10-05 1331
1）要求：  完成一个java application应用程序，在应用程序主进程中新开一个线程，此线程进行死循环，每1秒被激活一次，激活时即在输出显示当前时间。 程序代码： import java.text.SimpleDateFormat; import java.util.Date; public class Timer implements Runnable { ...
Java多线程的应用
Fuzz
10-09 693
一般只要是产生的CPU资源浪费，就需要多线程来提升效率。 我们举一个例子，例如一个网络爬虫项目，其中有两个环节 1.数据抓取：假设平均每个网站的抓取大约需要50ms。 2.数据处理（遍历数据）：假设每个网站的数据处理需要 这样的话如果使用单线程，平均处理每个网站的时间大约是52ms。其实这样已经产生的大量的资源浪费。 在CPU进行数据抓取的50ms时，CPU的数据处理没办法进行，所以...
ThreadLocal线程应用
最新发布
08-10
在应用中，ThreadLocal 可以用来存储一些线程特有的上下文信息，例如用户身份信息、数据库连接、请求信息等。这些信息只需要在线程内部共享，不需要跨线程共享，使用 ThreadLocal 可以避免出现线程安全问题，并且...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xuruhua

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值