一、程序和執行緒的概念

1.程序和執行緒的定義

　　程序並不只是一段可以執行的程式碼，也包含了執行程式碼所需要的資源。

　　在作業系統來看，程序是資源管理的最小單元，而我們又知道，執行緒是程式執行的最小單元。

　　話說回來，Linux系統至少有一個程序，一個程式可以對應多個程序，一個程序只能對應一個程式，一個程序包含一個或多個執行緒。

　　所以，一個程序的組成實體實際是兩大部分：資源的集合和執行緒的集合。程序中的執行緒是動態的物件, 代表了程序指令的執行。資源，包括地址空間、開啟的檔案、使用者資訊等等，由程序內的執行緒共享。執行緒有自己的私有資料：程式計數器，棧空間以及暫存器。

　　總結來說，在linux系統下，程序主要具有以下四個要素：

　　1）有一個程式供其執行。這段程式不一定是程序所專有，可以與其他程序一起使用；

　　2）有起碼的“私有財產”，這就是程序專用的系統堆疊空間；

　　3）有“身份證”，也就是task_struct結構，也稱之為“程序控制塊”（PCB）。有了這個資料結構，程序才能成為核心排程的一個基本單位接受核心的排程。同時，這個結構又是程序的“財產登記卡”，記錄著程序佔用的各項資源。

　　4）有獨立的儲存空間，意味著擁有專有的使用者空間；還意味著除前述的系統空間堆疊外還有其專有的使用者空間堆疊。（PS：程序的系統空間是不能獨立的，除了各程序獨有的系統堆疊空間外，任何程序都不可能直接改變使用者空間的內容）。

　　以上條件是必要條件，缺少其中一條，都不能稱其為“程序”。如果只缺第四條，那就稱為“執行緒”。

　　在linux系統中，“程序”和“任務”是同一個意思，在核心的程式碼中常混用這兩個名詞和概念。例如每個程序都要有一個task_struct資料結構，而其號碼卻又是pid、喚醒一個睡眠程序的函式名為wake_up_process()。

　　之所以有這樣的情況是因為，linux源自Unix和i386系統結構，而unix中的程序在Intel的技術資料中稱為“任務”，嚴格來說有點區別，但是對於系統的實現來說是一回事。

2.task_struct的定義

　　作業系統通過一個稱作PCB(Process Control Block，程序控制塊)的資料結構管理一個程序，也稱為tesk_struct結構體，這個結構體包含了一個程序所需的所有資訊。它定義在linux-2.6.38.8/include/linux/sched.h檔案中。

　　除了最起碼的“財產”，即task_struct資料結構和系統堆疊之外，一個程序還要有一些附加的資源。例如，程序擁有堵路的儲存空間，就要有用於虛擬記憶體管理的mm_struct資料結構以及附屬的vm_area資料結構，以及相應的頁面目錄項和頁面表，

　　但這些都從屬於task_struct資源。task_struct資料結構在這方面相當於登記卡的作用，其具體結構原始碼如下：

struct task_struct
{
    /*
     * offsets of these are hardcoded elsewhere - touch with care
     */
    volatile long state;  /* -1 unrunnable, 0 runnable, >0 stopped */
    unsigned long flags;  /* per process flags, defined below */
    int sigpending;
    mm_segment_t addr_limit;   /* thread address space:
    0-0xBFFFFFFF for user-thead
    0-0xFFFFFFFF for kernel-thread
     */
    struct exec_domain *exec_domain;
    volatile long need_resched;
    unsigned long ptrace;
    int lock_depth; /* Lock depth */
    
    /*
     * offset 32 begins here on 32-bit platforms. We keep
     * all fields in a single cacheline that are needed for
     * the goodness() loop in schedule().
     */
    long counter;
    long nice;
    unsigned long policy;
    struct mm_struct *mm;
    int has_cpu, processor;
    unsigned long cpus_allowed;
    
    struct list_head run_list;
    unsigned long sleep_time;
    
    struct task_struct *next_task, *prev_task;
    struct mm_struct *active_mm;
    /* task state */
    struct linux_binfmt *binfmt;
    int exit_code, exit_signal;
    int pdeath_signal;  /*  The signal sent when the parent dies  */
    
    unsigned long personality;
    int dumpable:1;
    int did_exec:1;
    pid_t pid;
    pid_t pgrp;
    pid_t tty_old_pgrp;
    pid_t session;
    pid_t tgid;
    /* boolean value for session group leader */
    int leader;
    /*
     * pointers to (original) parent process, youngest child, younger sibling,
     * older sibling, respectively.  (p->father can be replaced with
     * p->p_pptr->pid)
     */
    struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
    struct list_head thread_group;
    /* PID hash table linkage. */
    struct task_struct *pidhash_next;
    struct task_struct **pidhash_pprev;
    wait_queue_head_t wait_chldexit; /* for wait4() */
    struct semaphore *vfork_sem; /* for vfork() */
    unsigned long rt_priority;
    unsigned long it_real_value, it_prof_value, it_virt_value;
    unsigned long it_real_incr, it_prof_incr, it_virt_incr;
    struct timer_list real_timer;
    struct tms times;
    unsigned long start_time;
    long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS];
    /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
    unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
    int swappable:1;
    /* process credentials */
    uid_t uid,euid,suid,fsuid;
    gid_t gid,egid,sgid,fsgid;
    int ngroups;
    gid_t groups[NGROUPS];
    kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
    int keep_capabilities:1;
    struct user_struct *user;
    /* limits */
    struct rlimit rlim[RLIM_NLIMITS];
    unsigned short used_math;
    char comm[16];
    /* file system info */
    int link_count;
    struct tty_struct *tty; /* NULL if no tty */
    unsigned int locks; /* How many file locks are being held */
    /* ipc stuff */
    struct sem_undo *semundo;
    struct sem_queue *semsleeping;
    /* CPU-specific state of this task */
    struct thread_struct thread;
    /* filesystem information */
    struct fs_struct *fs;
    /* open file information */
    struct files_struct *files;
    /* signal handlers */
    spinlock_t sigmask_lock; /* Protects signal and blocked */
    struct signal_struct *sig;
    
    sigset_t blocked;
    struct sigpending pending;
    
    unsigned long sas_ss_sp;
    size_t sas_ss_size;
    int (*notifier)(void *priv);
    void *notifier_data;
    sigset_t *notifier_mask;
    
    /* Thread group tracking */
    u32 parent_exec_id;
    u32 self_exec_id;
    /* Protection of (de-)allocation: mm, files, fs, tty */
    spinlock_t alloc_lock;
};

下面對結構中幾個重要的成分做介紹：

　　1）state（第6行）

　　該變量表示程序當前執行的狀態，具體定義如下：

1 #define TASK_RUNNING              0
2 #define TASK_INTERRUPTIBLE        1
3 #define TASK_UNINTERRUPTIBLE 2 4 #define TASK_ZOMBIE 4 //殭屍程序 5 #define TASK_STOPPED 8

　　狀態TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE均表示程序處於睡眠狀態。但是TASK_UNINTERRUPTIBLE表示程序處於“深度睡眠”，而不受“訊號”（signal，也稱軟中斷）的打擾，而TASK_INTERRUPTIBLE則可以因訊號的到來而被喚醒。核心中提供了不同的函式，讓一個程序進入不同深度的睡眠或將程序從睡眠中喚醒。具體地說，函式sleep_on()和wake_up()用於深度睡眠，而interruptible_sleep_on()和wake_up_interruptible()則用於淺度睡眠。深度睡眠一般只用於臨界區和關鍵性的部位，而“可中斷”的睡眠那就是通用的了。特別地，當程序在“阻塞性”的系統呼叫中等待某一事件發生時，應該進入可中斷睡眠，否則就不能對別的中斷做出反應，別的程序就不能通過發一個訊號來“殺掉”這個程序了。

　　TASK_RUNNING狀態並不是表示一個程序正在執行中，或者說這個程序就是“當前程序”，而是表示這個程序可以被排程執行而成為當前程序。當程序處於這樣的可執行（或就緒）狀態時，核心就將該程序的task_struct結構通過其佇列頭（見第30行）掛入一個“執行佇列”。

　　TASK_ZOMBIE狀態表示程序已經“去世”而戶口尚未登出。

　　TASK_STOPPED主要用於除錯的目的，程序接收到 一個SIGSTOP訊號後就將執行狀態改成     TASK_STOPPED而進入“掛起”狀態，然後在接收到SIGCONT訊號時又恢復繼續執行。

　　2）flags（第7行）

　　flags反應程序狀態相關資訊，但並不是執行狀態，而是與管理有關的其他資訊。

 1 #define PF_ALIGNWARN        0x00000001      /*print alignment warning msgs*/
 2 #define PF_STARTING         0x00000002      /*being created*/
 3 #define PF_EXITING 0x00000004 /*getting shut down*/  4 #define PF_FORKNOEXEC 0x00000040 /*forked but did not exec*/  5 #define PF_SUPERPRIV 0x00000100 /*uses super-user privileges*/  6 #define PF_DUMPCORE 0x00000200 /*dumped core*/  7 #define PF_SIGNALED 0x00000400 /*killed by signal*/  8 #define PF_MEMALLOC 0x00000800 /*Allocating memory*/  9 #define PF_VFORK 0x00001000 /*wake up parent in mm_release*/ 10 #define PF_USEDFPU 0x00100000 /*task used FPU this quantum(SMP)*/

　　3）sigpending(第8行)

　　表示程序收到了“訊號”但是尚未處理。

　　4）counter（第23行）

　　與程序排程有關

　　5）add_limit

　　虛擬地址空間的上限，對程序而言是其使用者空間的上限，所以是0xbfff ffff;對核心執行緒而言則是系統空間額的上限，所以是0xffff ffff

　　6)binfnt

　　應用程式的檔案格式。

　　7）pgrp,session,leader

　　當一個使用者登入時，就開始了一個程序組（session），此後建立的程序都屬於這同一個session。

　　8）user

　　指向一個user_struct結構，該資料結構代表程序所屬的使用者。

　　9）rlim

　　這是一個結構陣列，表明程序歲各種資源的使用數量所受的限制。

3.task_struct如何在linux中被管理

　　task_struct可以以三種方式被管理，他們分別是：樹，雜湊表和連結串列，具體如下圖，其中圓代表一個個程序的task_struct。