说线程

其实要我说线程，我是不知道说什么的，我不能清晰的说出线程的历史，只是大致了解过（从LinuxThreads 到 NPTL和NGPT之争）；我也不知道线程在内核层面是具体怎样的形态，只是知道内核是不会区分线程和进程的，而且线程和进程一样也是task_struct结构体，而且会以线程组的形式存在（主线程即进程就是组长）；我也不能算一个入门的多线程服务端编程的c++程序员，因为一个是对c++所知甚少，还有就是多线程编程之间诸如如何解决同步，如何解决死锁，如何合理使用线程等问题我也没有研究过多少……基于这些局限，我能说的就寥寥无几了，但是我还是在准备的过程中找到好多详细的资料，我把这些资料分享给大家，也算是我的收获，那接下来，我会说到：

• 从启动说到线程
• 线程和进程之间的小区别
• 如何正确的使用线程？数量越多越好？
• 小扩展

一：从启动说到线程

这个开头开的有点远，当我们按下计算机电源键的一刻，计算机启动了，（有关启动可以参考下面的博客）

按下计算机电源键的一刻发生了什么(1)?

按下计算机电源键的一刻发生了什么(2)?

计算机启动之后，执行的第一个程序实际上是BIOS，它本身就是一个程序，然后重要的一步是init进程的产生，之后产生的所有进程全都是init进程或者其子进程、子子进程...等fork出来的，如果在你的代码中不小心出现了pthread_create和std::thread之类的代码，那会让这个主线程调用clone这个系统调用。然后子线程就产生了。有关产生的这个线程的前世今生，大家参考刘欢学长的下面这篇博客：

Linux线程的前世今生

二：线程和进程之间的小区别

1：执行代码的区别

线程代码如下：

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

void *thread(void *arg){}      //线程函数什么也不干

int main(int argc,char *argv[])
{
    pthread_t  thid;
    if(pthread_create(&thid,NULL,thread,NULL) != 0) {
            perror("pthread_create");
    }
    printf("hello\n");     //会执行一次
    return 0;
}

因为线程一旦创建，就会默认去执行线程函数，之后如果没有被join，就从线程函数中默认结束。pthread_create之后的代码实际上与它没有什么关系。所以上面的输出只会输出一次。是主线程执行下来之后输出的。

进程代码如下：

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

int main(int argc,char *argv[])
{
    fork();
    printf("hello\n");
    return 0;
}

进程的代码会输出两次，原因是fork之后的进程父进程和子进程都会执行剩余的代码，并且对于代码的原则是如果子进程直接执行exec，不修改变量的值，那么父子进程共用一份代码，如果子进程要修改变量的值，那么再复制一份，为其开辟自己的空间。

2：数据域的区别

线程代码如下：

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

int a = 0;

void *thread_1(void *args)
{
    a += 5;
    printf("a in thread_1 is %d\n",a);
}

void *thread_2(void *args)
{
    sleep(1);

    a += 5;
    printf("a in thread_2 is %d\n",a);

}

int main(int argc, char *argv[])
{
    pthread_t thread1, thread2;

    pthread_create(&thread1, NULL, thread_1, NULL);
    pthread_create(&thread2, NULL, thread_2, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

说明了线程之间是共享进程的数据的，线程1和线程2对a的修改都体现了出来。子线程还会共享主线程的变量、堆栈、地址空间、等，但是它还是会有自己的唯一的线程ID、私有数据等。

进程代码如下：

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

int a = 0;

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

    pid = fork();
    if(pid == 0) {
        a += 5;
        printf("a in child is %d\n",a);
    }
    if(pid != 0) {
        sleep(2);
        a += 5;
        printf("a in father is %d\n",a);
    }
    return 0;
}

这说明了子进程虽然会继承父进程的某些值，但是如果一旦修改这些值，子进程还是会有自己的空间去保存这些值的。

3：一个进程能开多少个线程？

环境交待：32位操作系统

32位操作系统的支持4G大小的虚拟地址空间，Linux默认会为内核分配1G左右，剩下的3G就是我们能用来创建线程的了，那我们用3G / （一个线程的空间） = 能创建的最大线程数。

用ulimit -s 查看系统默认为一个创建的新线程分配的栈空间大小（单位：K）：

看情况也就10M左右，那我们用：
（3*1024）/ 10 = 307.6 大约是307个左右，我们通过下面的程序验证下：

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

void *thread_func(void *args)
{
    printf("tid: %u  thread id: %u\n", getpid(), pthread_self());

    while(1) {
        sleep(10);
    }
}

int main(int argc, char *argv[])
{
    pthread_t thread;
    int count = 0;

    //while 循环不断创建线程
    while (pthread_create(&thread, NULL, thread_func, NULL) == 0){  
        count++;
    }

    perror("Create Error:");
    printf("Max Count:%d\n", count);

    return EXIT_SUCCESS;
}

304 个，因为还有系统代码，线程切换等的开销，因此这个数据还是相当准的，也就是我们32系统下一个进程能创建的最大线程数大约是300个，这当然有条件：ulimit -s大小为10M，我们也可以自己设置栈的大小，这个自行百度。

三：如何正确的使用线程？数量越多越好？

参考本山学长的这篇博客：

LinuxC多线程求和

由此我们知道线程的数量并不是越多越好，实际情况我们需要实际处理。因为线程之间本身的切换还是需要一定空间和时间的，如果我们让线程工作的时间甚至少于线程之间切换的时间，那么将会得不偿失。

四：小拓展

1：协程

这个概念实际上我们可以把它理解为在用户态模拟的线程，因此我们可以自己定义协程的结构，这样就使得协程的大小可以很小，而且通过程序之间的控制逻辑使得他们不一定按照顺序执行，从而便于并发，具体请参考：

协程—廖雪峰

2：并发语言Erlang

我自己并没有学习过Erlang，只是听王伟豪学长说过Erlang天生支持并发，看到这个语言1～2秒之内能并发出那么多进程(不是操作系统的概念)，我还是感受到了强大，参考他下面博客，能大概了解意思。

Erlang并发编程

3：“池”化思想

这也是并发处理一种非常简单和基本的思想，先初始化好资源，然后等着服务临，参考我自己的这篇博客:

Linux&C实现简单线程池