看看多线程,其实没那么可怕----小话多线程(1)

于 2012-08-02 09:53:46 发布
阅读量5.1k 收藏 5
点赞数 4
分类专栏： 小话多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxsjabcabc/article/details/7820105
版权

作者：陈曦

日期：2012-8-2 9:55:28 

环境：[Mac 10.7.1 Lion Intel i3 支持64位指令 gcc4.2.1 xcode4.2]

转载请注明出处


Q1： 对于主线程，创建一个子线程，如何传参数给它？

A： 对于pthread线程接口，线程函数参数就满足了这个要求。如下代码：

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

#define PRINT_D(intValue)   printf(#intValue" is %d\n", (intValue));
#define PRINT_U(uintValue)   printf(#uintValue" is %lu\n", (uintValue));
#define PRINT_STR(str)      printf(#str" is %s\n", (str));

// son thread
void    *son_thread_func(void *arg)
{
    char *s = (char *)arg;
    PRINT_STR(s)
    return NULL;
}


// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;

    ret = pthread_create(&son_thread, NULL, son_thread_func, "son thread");  
    if(ret != 0)
    {
        perror("pthread_create error");
        return -1;
    }
    
    ret = pthread_join(son_thread, NULL);
    if(ret != 0)
    {
        perror("pthread_join error");
        return -1;
    }
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

运行结果： 
s is son thread
[Main Thread]End...

Q2： 上面的传递参数，可以将主线程内部的栈变量直接传递给子线程吗？

A： 当然可以，不管是主线程还是子线程，虽然它们的堆栈不同，但是堆栈同属进程空间，各个线程都可以使用(当然，有的是只读区域只能读)。如下代码：

// son thread
void    *son_thread_func(void *arg)
{
    int *i = (int *)arg;
    printf("son thread i: %d\n", *i);
    *i = 100;       // modify main thread local var: local
    return NULL;
}


// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    int local = 12;

    // pass the local value to son thread
    ret = pthread_create(&son_thread, NULL, son_thread_func, &local);  
    if(ret != 0)
    {
        perror("pthread_create error");
        return -1;
    }
    
    ret = pthread_join(son_thread, NULL);
    if(ret != 0)
    {
        perror("pthread_join error");
        return -1;
    }
    
    // now output the value that be modified by son thread
    PRINT_D(local)
    printf("[Main Thread]End...\n");
    
    return 0;     
}

上面的代码，头文件和一些宏定义和最初的代码一致，因为篇幅问题就不会一直用完整的代码了。

上面的代码中，父线程将局部变量local地址传递给子线程，子线程修改它的值； 子线程返回后，父线程再输出local的值。

son thread i: 12
local is 100
[Main Thread]End...

Q3： 子线程的返回值void *, 它如何被主线程使用？

A： 主线程调用pthread_join阻塞自己，等待子线程执行完毕； pthread_join函数的第二个参数即可接收子线程的返回值。如下代码：

// son thread
void    *son_thread_func(void *arg)
{
    int *i = (int *)arg;
    *i = 100;       // modify main thread local var: local
    return (void *)*i;
}


// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    int local = 12;
    void *sonthread_ret;

    ret = pthread_create(&son_thread, NULL, son_thread_func, &local);  
    if(ret != 0)
    {
        perror("pthread_create error");
        return -1;
    }
    
    // sonthread_ret will store the son thread's return value
    ret = pthread_join(son_thread, &sonthread_ret);  
    if(ret != 0)
    {
        perror("pthread_join error");
        return -1;
    }
    
    PRINT_D((int)sonthread_ret)
    printf("[Main Thread]End...\n");
    
    return 0;     
}

上面的代码，pthread_join的第二个参数将会保存子线程返回的数值；主线程最终把它输出。结果如下： 
(int)sonthread_ret is 100
[Main Thread]End...

Q4： pthread_create和pthread_join的函数返回值如果是非0，说明不成功，判断语句长度有点长，能不能缩短点？

A： 使用宏。如下：

#define PTHREAD_ERROR(func, ret, return_value)     \
if((ret) != 0)        \
{   \
perror(#func" error");  \
printf("ret is %d\n", (ret));   \
return (return_value);  \
}

上面的main函数代码就缩短为： 
// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    int local = 12;
    void *sonthread_ret;

    ret = pthread_create(&son_thread, NULL, son_thread_func, &local);  
    PTHREAD_ERROR(pthread_create, ret, -1)
    
    // sonthread_ret will store the son thread's return value
    ret = pthread_join(son_thread, &sonthread_ret);  
    PTHREAD_ERROR(pthread_join, ret, -1)
    
    PRINT_D((int)sonthread_ret)
    printf("[Main Thread]End...\n");
    
    return 0;     
}

看起来关键和主体部分更容易看出来。


Q5： main函数最后的返回值改为  return  -1; 后，为什么在bash中执行后，查看返回值得到的是255呢？


A： 这是因为在bash中，$?是无符号型整数，并且是1个字节的。-1在内存中1字节保存的是0xFF,所以得到255.


Q6： 子线程调用exit一样会结束进程吗？

A： 是的。但是这里要注意子线程直接结束进程主线程是否还需要做什么，同时内存和资源的释放需要得到正确处理。

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

#define PRINT_D(intValue)   printf(#intValue" is %d\n", (intValue));
#define PRINT_U(uintValue)   printf(#uintValue" is %lu\n", (uintValue));
#define PRINT_STR(str)      printf(#str" is %s\n", (str));

#define RETURN_ERROR(func, ret, return_value)     \
if((ret) != 0)        \
{   \
perror(#func" error");  \
printf("ret is %d\n", (ret));   \
return (return_value);  \
}

// son thread
void    *son_thread_func(void *arg)
{
    exit(-1);
    return NULL;
}

void    exit_process()
{
    printf("process will exit\n");
}

// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    
    ret = atexit(exit_process);
    RETURN_ERROR(atexit, ret, -1)
    
    ret = pthread_create(&son_thread, NULL, son_thread_func, NULL);  
    RETURN_ERROR(pthread_create, ret, -1)
    
    ret = pthread_join(son_thread, NULL);  
    RETURN_ERROR(pthread_join, ret, -1)
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

上面的代码中，主线程注册了进程结束事件； 在子线程中调用exit结束进程，最后的输出： 
process will exit

可以看到，atexit注册的函数执行了，但是主线程最后的输出没有完成。可以看到，子线程调用exit可能导致主线程不能正常完成操作，所以需要小心调用。同时，在这里，之前的PTHREAD_ERROR宏也被改为了RETURN_ERROR.



Q7： pthread_create创建子线程返回后，子线程就可能已经执行了，有什么办法让此函数返回后子线程函数具体代码还没有开始执行？

A： 可以使用互斥体，主线程调用pthread_create前和子线程开始执行时用互斥体锁住。

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

#define PRINT_D(intValue)   printf(#intValue" is %d\n", (intValue));
#define PRINT_U(uintValue)   printf(#uintValue" is %lu\n", (uintValue));
#define PRINT_STR(str)      printf(#str" is %s\n", (str));

#define FOREVER_PRINT       { while(1)    printf("...");}

#define RETURN_ERROR(func, ret, return_value)     \
if((ret) != 0)        \
{   \
perror(#func" error");  \
printf("ret is %d\n", (ret));   \
return (return_value);  \
}

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// son thread
void    *son_thread_func(void *arg)
{
    int i = 0;
    
    pthread_mutex_lock(&mutex);
    printf("son thread:%d\n", i);
    pthread_mutex_unlock(&mutex);
    return NULL;
}



// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    
    pthread_mutex_lock(&mutex);
    printf("pthread_create begin...\n");
    ret = pthread_create(&son_thread, NULL, son_thread_func, NULL);  
    RETURN_ERROR(pthread_create, ret, -1)
    sleep(1);   
    printf("pthread_create ok...\n");
    pthread_mutex_unlock(&mutex);
    
    ret = pthread_join(son_thread, NULL);
    RETURN_ERROR(pthread_join, ret, -1)
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

上面的代码，主线程创建子线程代码前面使用mutex进行了lock操作；创建完毕后，主线程睡眠1秒，然后解锁。下面是输出结果： 

pthread_create begin...
pthread_create ok...
son thread:0
[Main Thread]End...

可以看出，尽管创建完子线程主线程睡眠1秒，因为mutex被锁住的原因，子线程函数代码还无法真正执行。



Q8： 为什么有时使用printf输出数据，执行后却看不到任何数据输出？

A： 这很可能是printf使用了缓冲导致的,如果需要及时在控制台看到输出，需要使用fflush(stdout);或者使用使用换行符作为输出结束。



Q9： 如何判断当前执行线程是否是主线程？

A： 如果仅仅在主线程或者子线程执行函数中，这基本上不需要判断就可以知道是否是主线程；但是，如果它们都调用了另外一个函数，那么在调用此函数时到底是主线程还是子线程就可能需要判断了。

pthread_t main_thread;

void    print_hello()
{
    if(pthread_equal(pthread_self(), main_thread))
        printf("main thread call it\n");
    else
         printf("son thread call it\n");
    printf("hello\n");
}

// son thread
void    *son_thread_func(void *arg)
{
    print_hello();
    return NULL;
}

// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    
    main_thread = pthread_self();   // save main thread
    ret = pthread_create(&son_thread, NULL, son_thread_func, NULL);  
    RETURN_ERROR(pthread_create, ret, -1)
    
    print_hello();
    
    ret = pthread_join(son_thread, NULL);
    RETURN_ERROR(pthread_join, ret, -1)
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

pthread_self得到当前线程的pthread_t类型数据， 通过pthread_equal即可判断线程对应的pthread_t类型是否相同，也就可以比较线程相同。

如下输出结果：

main thread call it
son thread call it
hello
hello
[Main Thread]End...


Q10： 为什么主线程调用print_hello函数的两句printf的输出是分离的?

A： 这就体现了线程并发执行的特性，创建了子线程，它就会开始运行，它和主线程并发运行，可以说，一般情况下，根本不会知道到底是哪个线程一定会被执行，这完全依赖于操作系统的调度策略； 当然，如果有意进行了睡眠、延迟，这样会一般改变执行的顺序。如果不希望出现上面的这种分离情况，可以改代码：

// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    
    main_thread = pthread_self();   // save main thread
    print_hello();
    
    ret = pthread_create(&son_thread, NULL, son_thread_func, NULL);  
    RETURN_ERROR(pthread_create, ret, -1)
    
    ret = pthread_join(son_thread, NULL);
    RETURN_ERROR(pthread_join, ret, -1)
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

上面将主线程的print_hello放到创建子线程前面，就可以避免输出错乱了： 

main thread call it
hello
son thread call it
hello
[Main Thread]End...


Q11： 为什么上面的两个线程各自调用printf输出，输出结果却没有出现输出数据混乱显示在一起？printf内部已经实现了互斥访问了吗？

A： 是的。POSIX标准要求ANSI I/O函数是实现互斥访问的。c语言的I/O函数在各个主流平台上，基本上都实现了互斥访问。当然，各个平台可能也保留了未实现互斥访问的I/O 函数。比如，putchar_unlocked函数等等。putchar_unlocked是和putchar对应的，前面表示没有对输出加锁，后面进行了加锁。下面就比较它们的效率：

#include <time.h>

#define	MACRO_TIME_BEGIN(loopCount)	\
{		\
clock_t begin, end;		\
begin = clock();		\
for(int i = 0; i < (loopCount); ++i)	\
{		\

#define	MACRO_TIME_END		\
}		\
end = clock();	\
printf("\ntime is %f s\n", (double)(end - begin) / CLOCKS_PER_SEC);	\
}

flockfile(stdout);              // lock stdout
MACRO_TIME_BEGIN(100000)
putchar_unlocked('a'); 
MACRO_TIME_END                  // 0.170801 s
funlockfile(stdout);            // unlock stdout
    
MACRO_TIME_BEGIN(100000)
putchar('a');
MACRO_TIME_END                  // 0.193599 s

两个操作均操作10万次，上面的耗时表示几次测试的一个平均数值。可以看出，putchar_unlocked少了加解锁过程，耗时少一些。



Q12： 对于新创建的线程，可以修改它的堆栈大小吗？

A： 对于主线程，可以根据系统或者编译器设置堆栈大小； 对于子线程，可以通过pthread_attr_setstacksize来设置堆栈大小，但是必须在创建线程时传入此属性参数。如下首先是获取堆栈大小的示例：

// son thread
void    *son_thread_func(void *arg)
{
    // use a 512KB stack， buf is too big that it will crash
    char buf[524288] = {0}; 
    
    return NULL;
}

// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    pthread_attr_t thread_attr;
    size_t stack_size;
    
    ret = pthread_attr_init(&thread_attr);
    RETURN_ERROR(pthread_attr_init, ret, -1)
    ret = pthread_attr_getstacksize(&thread_attr, &stack_size);
    RETURN_ERROR(pthread_attr_getstacksize, ret, -1)
    PRINT_U(stack_size)
    
    ret = pthread_create(&son_thread, &thread_attr, son_thread_func, NULL);  
    RETURN_ERROR(pthread_create, ret, -1)
    
    ret = pthread_attr_destroy(&thread_attr);
    RETURN_ERROR(pthread_attr_destroy, ret, -1)
    ret = pthread_join(son_thread, NULL);
    RETURN_ERROR(pthread_join, ret, -1)
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

pthread_create的第二个参数传入了pthread_attr_t类型的属性参数，此属性中包含了堆栈大小。运行： 

stack_size is 524288
Bus error: 10

可以看到，子线程堆栈大小默认为524288， 即512KB.  后面的执行出现错误了。使用xcode调试，

可以看出，确实在子线程栈对象buf处出现了异常。对于堆栈大小，mac系统默认主线程为8MB， 子线程默认512KB， ios上主线程默认1MB， 子线程为512KB.下面就通过代码来修改子线程堆栈，使得子线程不崩溃：

// main thread
int main(int argc, char **argv)
{
    pthread_t son_thread;
    int ret;
    pthread_attr_t thread_attr;
    size_t stack_size;
    
    ret = pthread_attr_init(&thread_attr);
    RETURN_ERROR(pthread_attr_init, ret, -1)
    ret = pthread_attr_getstacksize(&thread_attr, &stack_size);
    RETURN_ERROR(pthread_attr_getstacksize, ret, -1)
    PRINT_U(stack_size)
    
    // set big stack, than the son thread won't crash
    ret = pthread_attr_setstacksize(&thread_attr, stack_size * 2);    
    RETURN_ERROR(pthread_attr_setstacksize, ret, -1)
    
    ret = pthread_attr_getstacksize(&thread_attr, &stack_size);
    RETURN_ERROR(pthread_attr_getstacksize, ret, -1)
    printf("stack_size new value: %d\n", stack_size);
    
    ret = pthread_create(&son_thread, &thread_attr, son_thread_func, NULL);  
    RETURN_ERROR(pthread_create, ret, -1)
    
    ret = pthread_attr_destroy(&thread_attr);
    RETURN_ERROR(pthread_attr_destroy, ret, -1)
    ret = pthread_join(son_thread, NULL);
    RETURN_ERROR(pthread_join, ret, -1)
    
    printf("[Main Thread]End...\n");
    
    return 0;     
}

输出结果： 

stack_size is 524288
stack_size new value: 1048576
[Main Thread]End...

程序正常结束。


这篇主要讲述了多线程创建的基本过程，下一篇将是多线程退出需要注意的地方。


作者：陈曦

日期：2012-8-2 9:55:28  

环境：[Mac 10.7.1 Lion Intel i3 支持64位指令 gcc4.2.1 xcode4.2]

转载请注明出处


程序员小迷
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
博客
不同语言的转义字符
08-28 392
对于人生，什么时候都感觉不够满意。编程语言的字符集是有限的，有限的字符集表达更多的功能，引入了转义字符之类的特殊字符。
博客
字符和字符串
08-28 424
单个字符(一般被”包围)和单个字符的字符串(一般被’包围)看起来很像，实则可能天差地别。脚本语言可以把任何字面量看成字符串，它的处理更简单优雅，对于编译型语言，程序员必然要面对差异。
博客
未初始化的变量
08-27 630
学习C语言局部变量，经常听到这个说法。为什么局部变量默认是未初始化的？解释它需要理解程序结构和栈操作。
博客
语言的基本运算
08-27 195
编程语言基本数据类型的加减乘除，看起来都很像。它们都和数学公示很像，除了乘法不能用X或x，这个是字母，除法不能用÷，因为这个字符在键盘上看不到。
博客
语言的”一等公民”
08-26 321
一等公民，英文为”First-Class Citizen”. 一般而言，某个类型支持语言定义的所有操作，包括赋值、修改、参数传递和参数返回。编程语言的基本类型一般都是一等公民，比如C语言的int类型。
博客
数据类型大小
08-26 922
编译型语言数据类型大小比较确定，可能有多种，但具体在特定平台特定编译器，大小一定是确定的。解释型语言或脚本处理数据类型更自由，默认看成“字符串”，在做数值运算自动转换。本文不过多讨论脚本类语言，它们不太关心这么多细节。
博客
基本数据类型
08-25 368
大部分编程语言支持基本的数据类型，形如整形、浮点型和字符、字符串类型。
博客
Http/Https 请求慢的解决办法
08-25 624
2.HTTP2.0多路复用通过多个请求 共享一个 TCP 连接的方式，解决了HTTP request层面的 队头阻塞（HOL blocking ，即Head of Line blocking）的问题，即解决了HTTP 1.x中的队头阻塞问题，但TCP层面的队头阻塞问题（由于丢失或延迟的数据包导致重传阻塞）并未解决，基于QUIC（Quick UDP Internet Connections）的HTTP/3基本可以解决队头阻塞问题。和传统的 tcp socket 相似，基于 tcp 协议，提供双向的数据通道。
博客
语言的标识符
08-24 168
包括关键字、运算符、结束符、注释符等都是TOKEN的一种，词法分析分割出TOKEN最终送给语法分析处理。ALGOL60首创提出BNF范式，上下文无关、支持递归的语法规则表达，极佳地支持编程语言完整性。助您在编程路上越走越好！
博客
HTTP2.0 相对 HTTP1.x 的优化点
08-24 265
2.HTTP2.0多路复用通过多个请求 共享一个 TCP 连接的方式，解决了HTTP request层面的 队头阻塞（HOL blocking ，即Head of Line blocking）的问题，即解决了HTTP 1.x中的队头阻塞问题，但TCP层面的队头阻塞问题（由于丢失或延迟的数据包导致重传阻塞）并未解决，基于QUIC（Quick UDP Internet Connections）的HTTP/3基本可以解决队头阻塞问题。HTTP2.0会将所有传输的数据分割为更小的消息和帧，并对它们进行二进制编码。
博客
编程语言版本发展
08-23 422
地心说到日心说，再到平行宇宙猜想，不断提醒我们，世界万物都在不断发展变化中，编程语言一样如此。如下列出编程语言发展大版本，小版本可能太多，无法全部列出。微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。
博客
面向对象设计
08-23 410
通常的认知，面向对象程序设计最早从Simula发展而来，而后的SmallTalk也为面向对象提供了参考。ObjC借用SmallTalk消息的概念，C++扩大发展了OOP技术，为Java/C#等语言提供了坚实的基础。还有其他语言，Module-2提出模块MODULE概念，可以封装子程序和数据结构，限制访问权限，Clu提出了里氏替换原则，也为OOP设计提供了思路。
博客
语言闪光点
08-22 167
微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。助您在编程路上越走越好！
博客
未定义行为
08-22 254
未定义行为的另外一个称呼是”由实现定义”。C语言作为系统级别语言，不能因为不同平台的差异修改C标准，造成标准不”标准”。C语言采用了“渣男”的处理方式->不负责。这造成了移植性的问题，但这不是C语言的错误。int类型长度是多少，C标准未定义。除法和取模如果有负数参与，结果是向上取整还是向下取整由实现定义。Java作为中间件级语言，为了统一，不能像C语言那样给出不确定。比如int就是4字节，而不是像C语言那样，规定至少大小和short一样(这个规定了什么?C#一样也不会给出模棱两可的数据类型。
博客
编译环境揭秘
08-21 672
不同平台因为偏好差异，编译环境的准备会有差异。对于MSVC，微软提供简单的VS安装界面，比较省心。在Ubuntu发行版，gcc/make等程序可能不自带，当需要安装这些软件时就需要不少命令。当然比较麻烦，提供了统一的build-essential方便程序员，在Fedora上用development-tools.
博客
格式串的奥秘
08-21 325
编程语言毕竟是文本，只在ASCII码内无法表达更多的含义，如果不用新的函数或者关键字，就需要用“转义”的字符串格式来代表特定格式串。这就是格式串的来源。
博客
编译器揭秘
08-20 847
从上世纪50年代开始，编程语言五花八门，编译器和解释器层出不穷。此处只列出常见编程语言的编译器和解释器信息，不常见的编程语言有单独文章介绍。
博客
选择编程语言
08-20 364
大家真的数一数这个世界上的编程语言，就会知道，其实在某个旮旯拐角，曾经有某位大哥或者大姐，曾经“发明“过编程语言，但是因为一些原因，没办法让世界上所有人了解到，也不会流行开来。可是当人们需要做某个事情的时候，可选的编程语言其实没那么多。
博客
编译型语言和解释型语言
08-19 205
但事实上，解释型语言却在计算机发展很早的时期曾经出现过，当然这和前面一段话并不冲突，它是由自身的考虑，也并非为了推广。比如经典的TCC编译器，只需要一个-run参数即可让编译器编译并执行给出结果，本质上，每种编译型语言都可以这样做。
博客
古老的编程语言
08-19 438
它和Fortran同被称为上古时期四大编程语言，它对于编程语言的影响力极其深远，几乎后续所有命令式编程语言都受其思想感染，当然包括大家熟知的C/C++/Java/C#/JavaScript等等。事实上，它的实现确实如此。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值