精华内容
下载资源
问答
  • Linux c多线程执行顺序

    千次阅读 2012-01-05 13:18:21
    1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题...

    转自:http://blog.csdn.net/harry_lyc/article/details/6055734

    1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题。

    本实验用的系统为Ubuntu10.04 Thread model: posix

    gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5) 

    执行代码

    2.1 主线程和子线程的执行顺序问题

    2.1.1 主线程没有执行等待

    在主线程没有执行等待的情况下,即@1 @2 在注释掉的情况下。程序的运行如下。

    thread_one starting

    thread_two starting

    Main thread will sleep 1 S

    由此可见,多线程中子线程的执行是在主线程有空闲的条件下。即,如果主线程忙,或者是没有执行等待那么,子线程是不会执行的。

    2.1.2 程序在 @1 中执行等待, @2 中不等待

    执行结果如下:

    thread_one starting

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    thread_two starting

    Main thread will sleep 1 S

    程序在运行到I am one. loop 5 时,停顿一下,再执行。

    可见,主线程在@1 处,停了 1 秒,等待线程 1 执行,在线程 1 执行完毕后,有时还有时间,主线程继续等待完 1 秒后,重新执行。

    2.1.3 程序在 @1 中不执行等待, @2 中等待

    执行结果如下:

    thread_one starting

    thread_two starting

    Main thread will sleep 1 S

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    I am two. loop 0

    I am two. loop 1

    I am two. loop 2

    I am two. loop 3

    I am two. loop 4

    I am two. loop 5

    可见,在两个子线程运行后,主线程等待了1 秒,这是有充分的时间让子线程完成执行。两个现成的执行顺序为先后顺序。

    2.1.4 程序在 @1 中执行等待, @2 中等待

    执行结果如下:

    thread_one starting

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    thread_two starting

    Main thread will sleep 1 S

    I am two. loop 0

    I am two. loop 1

    I am two. loop 2

    I am two. loop 3

    I am two. loop 4

    I am two. loop 5

    程序在运行到I am one. loop 5 时,停顿了一下。等待够 1 秒后继续执行。

    在主线中,等待充分的时间使子线程执行,可以保证顺序执行。

    2.1.5 @1 @2 @3 @4 中个等待 1 秒。

    程序执行结果如下:

    thread_one starting

    I am one. loop 0

    thread_two starting

    Main thread will sleep 1 S

    I am one. loop 1

    I am two. loop 0

    @1 处,主线程等待了 1S ,让子线程 1 执行。子线程 1 执行一次循环,等待了 1S 。由于超过了主线程的等待时间,主线程在等待够 1S 后,继续执行。由于子线程 1 在子线程 2 显示输出时,被激活,所以子线程又循环一次后,子线程 2 输出结果。

    2.1.6 @1 @3 @4 中个等待 1 秒, @2 中等待 3

    程序执行如下:

    thread_one starting

    I am one. loop 0

    thread_two starting

    Main thread will sleep 3 S

    I am one. loop 1

    I am two. loop 0

    I am one. loop 2

    I am two. loop 1

    I am one. loop 3

    I am two. loop 2

    在主线程等待3 秒时,由于线程 1 和线程 2 都已经执行。并且执行一次循环后,等待 1 秒。所以,运行的结果,时线程 1 和线程 2 交替运行。

     

     

    gcc编译加上-lpthread 参数

     

    展开全文
  • linux c 多线程执行顺序解析

    千次阅读 2014-03-06 10:11:22
    1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题...

    1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题。

    本实验用的系统为Ubuntu10.04 Thread model: posix

    gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5) 

     

    执行代码

    1. #include<stdio.h>  
    2. #include<pthread.h>  
    3. #include<stdlib.h>  
    4. #include<unistd.h>  
    5. #include<signal.h>  
    6. static void thread_one(char* msg);  
    7. static void thread_two(char* msg);  
    8. int  main(int argc, char** argv)  
    9. {  
    10.     pthread_t th_one,th_two;  
    11.     char * msg="thread";  
    12.     printf("thread_one starting/n");  
    13.     if(pthread_create(&th_one,NULL,(void*)&thread_one,msg)!=0)  
    14.     {  
    15.         exit(EXIT_FAILURE);  
    16.     }  
    17.     sleep(1);// @1  
    18.     printf("thread_two starting/n");  
    19.     if(pthread_create(&th_two,NULL,(void*)&thread_two,msg)!=0)  
    20.     {  
    21.         exit(EXIT_FAILURE);  
    22.     }  
    23.     printf("Main thread will sleep 1 S/n");  
    24.     sleep(1);//@2  
    25.     return 0;  
    26.       
    27. }  
    28. static void thread_one(char* msg)  
    29. {  
    30.     int i=0;  
    31.     while(i<6)  
    32.     {  
    33.         printf("I am one. loop %d/n",i);  
    34.         i++;  
    35.         //sleep(1);  
    36.     }  
    37. }  
    38. static void thread_two(char* msg)  
    39. {  
    40.     int i=0;  
    41.     while(i<6)  
    42.     {  
    43.         printf("I am two. loop %d/n",i);  
    44.         i++;  
    45.         //sleep(1);  
    46.     }  
    47. }  

    2.1 主线程和子线程的执行顺序问题

    2.1.1 主线程没有执行等待

    在主线程没有执行等待的情况下,即@1 @2 在注释掉的情况下。程序的运行如下。

    thread_one starting

    thread_two starting

    Main thread will sleep 1 S

     

    由此可见,多线程中子线程的执行是在主线程有空闲的条件下。即,如果主线程忙,或者是没有执行等待那么,子线程是不会执行的。

    2.1.2 程序在@1 中执行等待, @2 中不等待

    执行结果如下:

    thread_one starting

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    thread_two starting

    Main thread will sleep 1 S

    程序在运行到I am one. loop 5时,停顿一下,再执行。

    可见,主线程在@1处,停了 1 秒,等待线程 1 执行,在线程 1 执行完毕后,有时还有时间,主线程继续等待完 1 秒后,重新执行。

    2.1.3 程序在@1 中不执行等待, @2 中等待

    执行结果如下:

    thread_one starting

    thread_two starting

    Main thread will sleep 1 S

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    I am two. loop 0

    I am two. loop 1

    I am two. loop 2

    I am two. loop 3

    I am two. loop 4

    I am two. loop 5

    可见,在两个子线程运行后,主线程等待了1秒,这是有充分的时间让子线程完成执行。两个现成的执行顺序为先后顺序。

    2.1.4 程序在@1 中执行等待, @2 中等待

    执行结果如下:

    thread_one starting

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    thread_two starting

    Main thread will sleep 1 S

    I am two. loop 0

    I am two. loop 1

    I am two. loop 2

    I am two. loop 3

    I am two. loop 4

    I am two. loop 5

    程序在运行到I am one. loop 5时,停顿了一下。等待够 1 秒后继续执行。

    在主线中,等待充分的时间使子线程执行,可以保证顺序执行。

    2.1.5 @1@2 @3 @4 中个等待 1 秒。

    程序执行结果如下:

    thread_one starting

    I am one. loop 0

    thread_two starting

    Main thread will sleep 1 S

    I am one. loop 1

    I am two. loop 0

    @1 处,主线程等待了 1S ,让子线程 1 执行。子线程 1 执行一次循环,等待了 1S 。由于超过了主线程的等待时间,主线程在等待够 1S 后,继续执行。由于子线程 1 在子线程 2 显示输出时,被激活,所以子线程又循环一次后,子线程 2 输出结果。

    2.1.6 @1@3 @4 中个等待 1 秒, @2 中等待 3

    程序执行如下:

    thread_one starting

    I am one. loop 0

    thread_two starting

    Main thread will sleep 3 S

    I am one. loop 1

    I am two. loop 0

    I am one. loop 2

    I am two. loop 1

    I am one. loop 3

    I am two. loop 2

    在主线程等待3秒时,由于线程 1 和线程 2 都已经执行。并且执行一次循环后,等待 1 秒。所以,运行的结果,时线程 1 和线程 2 交替运行。
    展开全文
  • 1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题...

    1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题。

    本实验用的系统为Ubuntu10.04 Thread model: posix

    gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5) 

    执行代码

    [cpp:firstline[1]] view plaincopyprint?
    1. #include<stdio.h>   
    2. #include<pthread.h>   
    3. #include<stdlib.h>   
    4. #include<unistd.h>   
    5. #include<signal.h>   
    6. static void thread_one(char* msg);  
    7. static void thread_two(char* msg);  
    8. int  main(int argc, char** argv)  
    9. {  
    10.     pthread_t th_one,th_two;  
    11.     char * msg="thread";  
    12.     printf("thread_one starting/n");  
    13.     if(pthread_create(&th_one,NULL,(void*)&thread_one,msg)!=0)  
    14.     {  
    15.         exit(EXIT_FAILURE);  
    16.     }  
    17.     sleep(1);// @1   
    18.     printf("thread_two starting/n");  
    19.     if(pthread_create(&th_two,NULL,(void*)&thread_two,msg)!=0)  
    20.     {  
    21.         exit(EXIT_FAILURE);  
    22.     }  
    23.     printf("Main thread will sleep 1 S/n");  
    24.     sleep(1);//@2   
    25.     return 0;  
    26.       
    27. }  
    28. static void thread_one(char* msg)  
    29. {  
    30.     int i=0;  
    31.     while(i<6)  
    32.     {  
    33.         printf("I am one. loop %d/n",i);  
    34.         i++;  
    35.         //sleep(1);   
    36.     }  
    37. }  
    38. static void thread_two(char* msg)  
    39. {  
    40.     int i=0;  
    41.     while(i<6)  
    42.     {  
    43.         printf("I am two. loop %d/n",i);  
    44.         i++;  
    45.         //sleep(1);   
    46.     }  
    47. }  

    2.1 主线程和子线程的执行顺序问题

    2.1.1 主线程没有执行等待

    在主线程没有执行等待的情况下,即@1 @2 在注释掉的情况下。程序的运行如下。

    thread_one starting

    thread_two starting

    Main thread will sleep 1 S

    由此可见,多线程中子线程的执行是在主线程有空闲的条件下。即,如果主线程忙,或者是没有执行等待那么,子线程是不会执行的。

    2.1.2 程序在 @1 中执行等待, @2 中不等待

    执行结果如下:

    thread_one starting

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    thread_two starting

    Main thread will sleep 1 S

    程序在运行到I am one. loop 5 时,停顿一下,再执行。

    可见,主线程在@1 处,停了 1 秒,等待线程 1 执行,在线程 1 执行完毕后,有时还有时间,主线程继续等待完 1 秒后,重新执行。

    2.1.3 程序在 @1 中不执行等待, @2 中等待

    执行结果如下:

    thread_one starting

    thread_two starting

    Main thread will sleep 1 S

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    I am two. loop 0

    I am two. loop 1

    I am two. loop 2

    I am two. loop 3

    I am two. loop 4

    I am two. loop 5

    可见,在两个子线程运行后,主线程等待了1 秒,这是有充分的时间让子线程完成执行。两个现成的执行顺序为先后顺序。

    2.1.4 程序在 @1 中执行等待, @2 中等待

    执行结果如下:

    thread_one starting

    I am one. loop 0

    I am one. loop 1

    I am one. loop 2

    I am one. loop 3

    I am one. loop 4

    I am one. loop 5

    thread_two starting

    Main thread will sleep 1 S

    I am two. loop 0

    I am two. loop 1

    I am two. loop 2

    I am two. loop 3

    I am two. loop 4

    I am two. loop 5

    程序在运行到I am one. loop 5 时,停顿了一下。等待够 1 秒后继续执行。

    在主线中,等待充分的时间使子线程执行,可以保证顺序执行。

    2.1.5 @1 @2 @3 @4 中个等待 1 秒。

    程序执行结果如下:

    thread_one starting

    I am one. loop 0

    thread_two starting

    Main thread will sleep 1 S

    I am one. loop 1

    I am two. loop 0

    @1 处,主线程等待了 1S ,让子线程 1 执行。子线程 1 执行一次循环,等待了 1S 。由于超过了主线程的等待时间,主线程在等待够 1S 后,继续执行。由于子线程 1 在子线程 2 显示输出时,被激活,所以子线程又循环一次后,子线程 2 输出结果。

    2.1.6 @1 @3 @4 中个等待 1 秒, @2 中等待 3

    程序执行如下:

    thread_one starting

    I am one. loop 0

    thread_two starting

    Main thread will sleep 3 S

    I am one. loop 1

    I am two. loop 0

    I am one. loop 2

    I am two. loop 1

    I am one. loop 3

    I am two. loop 2

    在主线程等待3 秒时,由于线程 1 和线程 2 都已经执行。并且执行一次循环后,等待 1 秒。所以,运行的结果,时线程 1 和线程 2 交替运行。

    展开全文
  • 关于linux c 多线程调度执行顺序

    千次阅读 2017-12-20 09:54:52
    最近在学习linux 下c语言的多线程调度,在博主李亚超的文章Linux C 多线程执行顺序问题(原链接:http://blog.csdn.net/harry_lyc/article/details/6055734#reply)一文中的下面回复有人探讨到线程之间是通过时间片...

    最近在学习linux 下c语言的多线程调度,在博主李亚超的文章Linux C 多线程执行顺序问题(原链接:http://blog.csdn.net/harry_lyc/article/details/6055734#reply)一文中的下面回复有人探讨到线程之间是通过时间片调度的,也就是说当某一个线程的时间片用完则会自动调用到其他的线程。

    我实验了一下,确实如此,最终的打印信息如下:

    thread_one starting
    thread_one created
    thread_two starting
    thread_two created
    I am two. loop 0
    I am two. loop 1
    I am two. loop 2
    I am two. loop 3
    I am two. loop 4
    I am two. loop 5
    Main thread begins loop
    I am one. loop 0
    I am one. loop 1
    I am one. loop 2
    I am one. loop 3
    I am one. loop 4
    I am one. loop 5
    ---------Main thread is done for loop----------
    Main thread will sleep 1 S

    可以发现,主线程开启了两个子线程之后,显示子线程 2 在运行,然后主线程运行,但是时间片用完之后,子线程 1 运行,然后再是主线程运行,结束loop。

    但是其中顺序的先后仍然不是十分清楚,搞懂之后再来进行补充。


    ----- 2017.12.23-----

    线程的顺序暂时可以认为是随机的,除非利用条件变量进行限定,否则顺序无法确定。

    展开全文
  • 【Linux】Linux多线程技术

    万次阅读 2018-09-05 15:57:23
    Linux多线程概念 线程的概念 线程是计算机科学中的一个术语,是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流,也称为轻量进程。它是系统独立调度和分配的基本单位。同一进程中的多个线程...
  • Linux多线程

    万次阅读 2018-06-22 11:11:04
    Linux多线程 1. 线程? 线程是一个进程内部的控制序列。线程共享进程数据,但线程也拥有自己私有的上下文数据、私有栈结构。是程序执行的最小单位。 2. Linux中的线程 Linux中的线程是用进程模拟的。在Linux...
  • 进程在理解线程之前,首先需要了解UNIX/Linux进程。 进程是由操作系统创建的,需要相当数量的“开销”。 进程包含有关程序资源和程序执行状态的信息,包括:它是一个在随机访问内存(RAM)中,正在执行程序,它是...
  • linux shell 多线程执行程序

    千次阅读 2019-06-19 09:40:59
    linux shell 多线程执行程序 Shell中并没有真正意义的多线程,要实现多线程可以启动多个后端进程,最大程度利用cpu性能。 直接看代码示例吧。 (1) 顺序执行的代码 #!/bin/bash date for i in `seq 1 5` do { echo ...
  • 1:多线程设计通常是比较麻烦的,因为它牵涉到,线程间的同步、和执行顺序问题。在用户没有设定线程间的调度策略时,系统默认采取基于时间片轮转的调度策略。本实验是在默认的调度策略下,测试线程间的执行顺序问题...
  • 本文主要对Linux下的多线程进行一个入门的介绍,虽然是入门,但是十分详细,希望大家通过本文所述,对Linux多线程编程的概念有一定的了解。具体如下。 1 线程基本知识 进程是资源管理的基本单元,而线程是系统调度的...
  • linux多线程编程

    2021-04-24 12:01:20
    linux多线程编程 linux线程介绍 进程与线程的区别 1 进程是资源分配的单元,创建进程时系统需要分配内存资源,而线程是资源调度的单元,共享进程中的地址空间,创建线程不会有新的开销. 2.执行效率不同.线程的执行效率...
  • Linux多线程程序设计

    2015-08-11 14:09:07
    线程线程可以理解为“轻量级”的进程,它与创建它的进程共享代码段和数据段,同时拥有自己独立的栈。
  • Linux 多线程

    2014-04-14 15:18:27
    Linux 平台上的多线程程序开发相对应其他平台(比如 Windows)的多线程 API 有一些细微和隐晦的差别。不注意这些 Linux 上的一些开发陷阱,常常会导致程序问题不穷,死锁不断。本文中我们从 5 个方面总结出 Linux ...
  • Linux多线程编程入门

    2021-01-20 14:55:49
     需要注意的是:即使程序运行在单核处理器上,也能够得到多线程编程模型的好处。处理器的数量并不影响程序结构,所以不管处理器个数多少,程序都可以通过线程得以简化。  linux操作系统使用符合POSI
  • Linux多线程编程

    千次阅读 2019-06-21 17:40:29
    作为多任务实现的一种机制,多线程应用得非常广泛,相对于多进程,多线程不仅运行效率高,而且还可以提高系统资源的使用效率。虽然网上关于多线程的讲解已经有一大堆,但出于学习的心态,有必要在这里做一下笔记。 ...
  • linux多线程设计

    2017-04-02 13:06:09
    linux多线程设计 概念 线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元。一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成。另外,线程是进程中的一个实体,是...
  • Linux多线程与同步

    千次阅读 2016-04-13 22:51:46
    Linux多线程与同步   典型的UNIX系统都支持一个进程创建多个线程(thread)。在LINUX基础中提到,Linux以进程为单位组织操作,Linux中的线程也都基于进程。尽管实现方式有异于其它的UNIX系统,但Linux...
  • linux 多线程信号总结

    2017-10-27 14:41:31
    多线程环境下,产生的信号是传递给整个进程的,一般而言,所有线程都有机会收到这个信号,进程在收到信号的的线程上下文执行信号处理函数,具体是哪个线程执行的难以获知。也就是说,信号会随机发个该进程的一个...
  • Linux线程执行顺序

    2020-10-22 15:22:48
    int pthread_create(pthread_t* pthread,...pthread_attr 线程属性设置,控制线程程序其他部分交互方式,常设为NULL,默认线程属性 start_routine 线程函数指针,是线程执行的代码,参数为void(*) arg 传递给start_

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 229,149
精华内容 91,659
关键字:

linux多线程执行顺序

linux 订阅