我现在觉得多线程，唯一的好处就是启动结束一个线程速度比启动结束一个进程的速度快！大家的意见呢？

同意楼上的,线程由于共享进程空间,所以交互方便,但需要一些同步机制,编程复杂些,如果处理不好会带来死锁,内存出错等问题.另外一个线程CORE掉,影响多有此进程的线程
进程相对安全一些,就是交互必须用IPC或者SOCKET等机制
另外创建线程的开销应该要比fork开销少些吧

线程可以共享进程的地址空间，这样可以方便一些。

通讯可能会更方便一些，方法多一些

Although the definition of a process may seem obvious, the concept of threads makes all of this less clear-cut. A thread allows a single program to run in multiple places at the same time. All the threads created (or spun off) by a single program share most of the characteristics that differentiate processes from each other. For example, multiple threads that originate from the same program share information on open files, credentials, current directory, and memory image. As soon as one of the threads modifies a global variable, all the threads see the new value rather than the old one.

Many Unix implementations (including AT&T's canonical System V release) were redesigned to make threads the fundamental scheduling unit for the kernel, and a process became a collection of threads that shared resources. As so many resources were shared among threads, the kernel could switch between threads in the same process more quickly than it could perform a full context switch between processes. This resulted in most Unix kernels having a two-tiered process model that differentiates between threads and processes.

-----------------------------------Linux Application Development,+Second+Edition

进程占用内存空间过多吧？

线程间并发访问数据需要同步看起来不方便，但这是避免不了的，而且效率也高
效率最高的IPC是共享内存，这种情况也是需要同步机制的
所以对比起来，还是用线程方便些

进程要占用进程号进程控制块,这也属于系统资源.
线程间切换要比进程间调度快一些.

    * The primary motivation for using Pthreads is to realize potential program performance gains.

    * When compared to the cost of creating and managing a process, a thread can be created with much less operating system overhead. Managing threads requires fewer system resources than managing processes.

      For example, the following table compares timing results for the fork() subroutine and the pthreads_create() subroutine. Timings reflect 50,000 process/thread creations, were performed with the time utility, and units are in seconds, no optimization flags.

      Note: don't expect the system and user times to add up to real time, because these are SMP systems with multiple CPUs working on the problem at the same time. At best, these are approximations.

                Platform                                fork()             pthread_create()
                                                real  user  sys  real  user  sys
      AMD 2.4 GHz Opteron (8cpus/node)          41.07  60.08  9.01  0.66  0.19  0.43
      IBM 1.9 GHz POWER5 p5-575 (8cpus/node)  64.24  30.78  27.68  1.75  0.69  1.10
      IBM 1.5 GHz POWER4 (8cpus/node)          104.05  48.64  47.21  2.01  1.00  1.52
      INTEL 2.4 GHz Xeon (2 cpus/node)          54.95  1.54  20.78  1.64  0.67  0.90
      INTEL 1.4 GHz Itanium2 (4 cpus/node)  54.54  1.07  22.22  2.03  1.26  0.67

    * All threads within a process share the same address space. Inter-thread communication is more efficient and in many cases, easier to use than inter-process communication.

    * Threaded applications offer potential performance gains and practical advantages over non-threaded applications in several other ways:
          o Overlapping CPU work with I/O: For example, a program may have sections where it is performing a long I/O 
            operation. While one thread is waiting for an I/O system call to complete, CPU intensive work can be performed by
            other threads.
          o Priority/real-time scheduling: tasks which are more important can be scheduled to supersede or interrupt lower 
            priority tasks.
          o Asynchronous event handling: tasks which service events of indeterminate frequency and duration can be 
            interleaved. For example, a web server can both transfer data from previous requests and manage the arrival of
            new requests. 

    * The primary motivation for considering the use of Pthreads on an SMP architecture is to achieve optimum performance. In particular, if an application is using MPI for on-node communications, there is a potential that performance could be greatly improved by using Pthreads for on-node data transfer instead.

    * For example:
          o MPI libraries usually implement on-node task communication via shared memory, which involves at least one memory  
            copy operation (process to process).
          o For Pthreads there is no intermediate memory copy required because threads share the same address space within a 
            single process. There is no data transfer, per se. It becomes more of a cache-to-CPU or memory-to-CPU bandwidth  
            (worst case) situation. These speeds are much higher.
          o Some local comparisons are shown below:   
                                                                           Pthreads Worst Case
                                         MPI Shared Memory Bandwidth     Memory-to-CPU Bandwidth
                   Platform                (GB/sec)                           (GB/sec)
            AMD 2.4 GHz Opteron          1.2                             5.3
            IBM 1.9 GHz POWER5 p5-575          4.1                             16
            IBM 1.5 GHz POWER4                  2.1                             4
            Intel 1.4 GHz Xeon                  0.3                             4.3
            Intel 1.4 GHz Itanium 2          1.8                             6.4

看来要好好学习了

来学习!!!