明白LINUX内核的高手进

zhaoyuaini

请问LINUX核心到底能否实现真正的多线程（并行处理），
也就是A，B两个程序真正的同时运行（多CPU情况下）。
感觉介绍的所有多线程函数都需要睡眠才能运行，所以内核根本不能真正的多线程。


如果真的能，那么如何使用，请大体的介绍下。

OstrichFly

原帖由 zhaoyuaini 于 2008-8-6 10:01 发表
我使用的是kernel_thread开辟的线程，所以是线程，我的问题也是该线程是否能和主线程同时并行，请赐教。
用的是2.6.18内核

1：kernel_thread开辟的任务可以认为是线程，理由：
它运行在内核态，并且一般仅访问内核地址空间的数据(对x86来说就是3G以上的空间)，
而这部分数据对于所有任务，映射的是相同的物理地址。
也就是说，它与其他任务使用共享内存，从这这个意义上说，它是线程，不是进程。
(用户态进程相反，它的地址空间虽然也包含共享的3G以上部分，但从一般意义上，它访问的主要是不共享的3G以下部分)

2：同时运行分为完全同时和分时运行
kernel_thread开辟的线程也属于任务，也参与任务调度。
单CPU下，是分时运行的，同一时间下不会与其它任务同时运行
多CPU下，可以在不同CPU上与其它任务同时运行

3：所谓的内核主线程
其实不存在。
内核只有在相应某项要求时，才会运行，不存在所谓的一直在运行的内核主线程。
比如：用户进程执行了syscall，会进入内核代码运行一段时间，然后返回用户程序
中断发生时，会进入内核代码运行一段时间，然后返回用户程序
也就是说，在任何时间，都会有某一个任务在运行(包括中断处理程序可以理解为运行在被中断程序的上下文，虽然不会使用这个任务的数据)
而不存在某个持续运行的内核主线程。

pilixuanke

首先声明俺不是高手，但这应该不妨碍一块就这个问题进行一下讨论吧

按照我的理解，对于多CPU的情况，内核肯定会实现真正意义上的并行处理，否则多CPU的性能优势何在？最简单的情况，两个完全不相关的程序运行时，就可以分别将它们分配到不同的CPU去运行，至于说一些具有共享数据的运行任务分配可以用SpinLock来实现互斥访问吧（具体不太清楚，因为现在俺还没写过什么内核相关的程序）。

一点个人想法，供讨论，希望引出大牛来、、

dreamice

声明一下，俺也不是高手。
SMP的确能够实现并行处理：1、每个cpu维护有自己的运行队列，所以实际上在调度程序运行的时候，各个cpu从自己的运行队列里面调度进程执行，这样可以实现并发；2、任何程序都可能睡眠，可能因为等待资源或者他的时间片耗尽而不得不进入非运行态——即移出CPU的运行队列，那么这个时候必然将调度性的进程运行，所以，多CPU或者单CPU系统中，睡眠和并发是没有直接关联的。3、关于如何使用的问题，如果你创建进程，没有特别的声明，是无法预测他在哪个CPU被调度的，而且，如果多cpu的各个运行队列进程数目相差太大，还需要均衡调度（2.6种load_balance()函数完成），即尽量保证各个cpu的运行队列拥有相差不大的可运行进程数。4、另外，内核是允许把一个进程和某个处理器绑定，以使之在特定的处理器上被调度执行的。LZ可以看看2.6内核进程调度的相关资料。

dreamice

如果回答合适，俺也想赚点分，哈哈 还需要理解什么的，楼主请说，呵呵。

sword0838

你的问题有问题，A，B两个程序同时执行，那是多进程，不是多线程。
即使是单核的CPU，只要支持HT超线程，就可以同时执行多线程。
多CPU下，执行多进程当然可以。

dreamice

他这里说的程序应该就是指进程。
单CPU能同时执行多线程？？那也是分时复用吧。

sword0838

原帖由 dreamice 于 2008-8-5 15:31 发表
他这里说的程序应该就是指进程。
单CPU能同时执行多线程？？那也是分时复用吧。

对，单CPU也能执行多线程，不是分时，CPU内有多个运算部件和寄存器，整数的，浮点的，不同需求的线程线程可以同时在不同部件内执行。

zhaoyuaini

我使用的是kernel_thread开辟的线程，所以是线程，我的问题也是该线程是否能和主线程同时并行，请赐教。
用的是2.6.18内核

dreamice

原帖由 zhaoyuaini 于 2008-8-6 10:01 发表
我使用的是kernel_thread开辟的线程，所以是线程，我的问题也是该线程是否能和主线程同时并行，请赐教。
用的是2.6.18内核

Linux的线程被称作轻量级进程，实际上内核对线程的调度跟普通进程的调度是没有什么差别的，正如我前面说到的。只是，线程之间共享了比父子进程更多资源而已。下面这段话我没有翻译，限于本人的英语水平，我想LZ看完应该比较清楚了。
LinuxThreads follows the so-called "one-to-one" model: each thread is actually a separate process in the kernel. The kernel scheduler takes care of scheduling the threads, just like it schedules regular processes. The threads are created with the Linux clone() system call, which is a generalization of fork() allowing the new process to share the memory space, file descriptors, and signal handlers of the parent.

Advantages of the "one-to-one" model include:

    * minimal overhead on CPU-intensive multiprocessing (with about one thread per processor);
    * minimal overhead on I/O operations;
    * a simple and robust implementation (the kernel scheduler does most of the hard work for us).

The main disadvantage is more expensive context switches on mutex and condition operations, which must go through the kernel. This is mitigated by the fact that context switches in the Linux kernel are pretty efficient.