mysileng

list_for_each()的定義：

1. /**  
2.  * list_for_each    -   iterate over a list  
3.  * @pos:    the &struct list_head to use as a loop counter.  
4.  * @head:   the head for your list.  
5.  */  
6. #define list_for_each(pos, head) \  
7.     for (pos = (head)->next, prefetch(pos->next); pos != (head); \  
8.         pos = pos->next, prefetch(pos->next))  

list_for_each_safe()的定義：

1. /**  
2.  * list_for_each_safe   -   iterate over a list safe against removal of list entry  
3.  * @pos:    the &struct list_head to use as a loop counter.  
4.  * @n:      another &struct list_head to use as temporary storage  
5.  * @head:   the head for your list.  
6.  */  
7. #define list_for_each_safe(pos, n, head) \  
8.     for (pos = (head)->next, n = pos->next; pos != (head); \  
9.         pos = n, n = pos->next)  

由上面兩個對比來看，list_for_each_safe()函數(shù)比list_for_each()多了一個中間變量n

當(dāng)在遍歷的過程中需要刪除結(jié)點時，來看一下會出現(xiàn)什么情況：

list_for_each()：list_del(pos)將pos的前后指針指向undefined state,導(dǎo)致kernel panic，另如果list_del_init(pos)將pos前后指針指向自身，導(dǎo)致死循環(huán)。

list_for_each_safe()：首先將pos的后指針緩存到n，處理一個流程后再賦回pos，避免了這種情況發(fā)生。

因此之遍歷鏈表不刪除結(jié)點時，可以使用list_for_each()，而當(dāng)由刪除結(jié)點操作時，則要使用list_for_each_safe()。

其他帶safe的處理也是基于這個原因。

一、 鏈表數(shù)據(jù)結(jié)構(gòu)簡介 

鏈表是一種常用的組織有序數(shù)據(jù)的數(shù)據(jù)結(jié)構(gòu)，它通過指針將一系列數(shù)據(jù)節(jié)點連接成一條數(shù)據(jù)鏈，是線性表的一種重要實現(xiàn)方式。相對于數(shù)組，鏈表具有更好的動態(tài)性，建立鏈表時無需預(yù)先知道數(shù)據(jù)總量，可以隨機分配空間，可以高效地在鏈表中的任意位置實時插入或刪除數(shù)據(jù)。鏈表的開銷主要是訪問的順序性和組織鏈的空間損失。

通常鏈表數(shù)據(jù)結(jié)構(gòu)至少應(yīng)包含兩個域：數(shù)據(jù)域和指針域，數(shù)據(jù)域用于存儲數(shù)據(jù)，指針域用于建立與下一個節(jié)點的聯(lián)系。按照指針域的組織以及各個節(jié)點之間的聯(lián)系形式，鏈表又可以分為單鏈表、雙鏈表、循環(huán)鏈表等多種類型，下面分別給出這幾類常見鏈表類型的示意圖：

1． 單鏈表

單鏈表是最簡單的一類鏈表，它的特點是僅有一個指針域指向后繼節(jié)點（next），因此，對單鏈表的遍歷只能從頭至尾（通常是NULL空指針）順序進行。

2． 雙鏈表

通過設(shè)計前驅(qū)和后繼兩個指針域，雙鏈表可以從兩個方向遍歷，這是它區(qū)別于單鏈表的地方。如果打亂前驅(qū)、后繼的依賴關(guān)系，就可以構(gòu)成"二叉樹"；如果再讓首節(jié)點的前驅(qū)指向鏈表尾節(jié)點、尾節(jié)點的后繼指向首節(jié)點（如圖2中虛線部分），就構(gòu)成了循環(huán)鏈表；如果設(shè)計更多的指針域，就可以構(gòu)成各種復(fù)雜的樹狀數(shù)據(jù)結(jié)構(gòu)。

3． 循環(huán)鏈表

循環(huán)鏈表的特點是尾節(jié)點的后繼指向首節(jié)點。前面已經(jīng)給出了雙循環(huán)鏈表的示意圖，它的特點是從任意一個節(jié)點出發(fā)，沿兩個方向的任何一個，都能找到鏈表中的任意一個數(shù)據(jù)。如果去掉前驅(qū)指針，就是單循環(huán)鏈表。

在Linux內(nèi)核中使用了大量的鏈表結(jié)構(gòu)來組織數(shù)據(jù)，包括設(shè)備列表以及各種功能模塊中的數(shù)據(jù)組織。這些鏈表大多采用在[include/linux/list.h]實現(xiàn)的一個相當(dāng)精彩的鏈表數(shù)據(jù)結(jié)構(gòu)。本文的后繼部分就將通過示例詳細(xì)介紹這一數(shù)據(jù)結(jié)構(gòu)的組織和使用。

二、 Linux 2.6內(nèi)核鏈表數(shù)據(jù)結(jié)構(gòu)的實現(xiàn)

盡管這里使用2.6內(nèi)核作為講解的基礎(chǔ)，但實際上2.4內(nèi)核中的鏈表結(jié)構(gòu)和2.6并沒有什么區(qū)別。不同之處在于2.6擴充了兩種鏈表數(shù)據(jù)結(jié)構(gòu)：鏈表的讀拷貝更新（rcu）和HASH鏈表（hlist）。這兩種擴展都是基于最基本的list結(jié)構(gòu)，因此，本文主要介紹基本鏈表結(jié)構(gòu)，然后再簡要介紹一下rcu和hlist。

鏈表數(shù)據(jù)結(jié)構(gòu)的定義很簡單（節(jié)選自[include/linux/list.h]，以下所有代碼，除非加以說明，其余均取自該文件）：

struct list_head {
	struct list_head *next, *prev;
};

list_head結(jié)構(gòu)包含兩個指向list_head結(jié)構(gòu)的指針prev和next，由此可見，內(nèi)核的鏈表具備雙鏈表功能，實際上，通常它都組織成雙循環(huán)鏈表。

和第一節(jié)介紹的雙鏈表結(jié)構(gòu)模型不同，這里的list_head沒有數(shù)據(jù)域。在Linux內(nèi)核鏈表中，不是在鏈表結(jié)構(gòu)中包含數(shù)據(jù)，而是在數(shù)據(jù)結(jié)構(gòu)中包含鏈表節(jié)點。

在數(shù)據(jù)結(jié)構(gòu)課本中，鏈表的經(jīng)典定義方式通常是這樣的（以單鏈表為例）：

struct list_node {
	struct list_node *next;
	ElemType	data;
};

因為ElemType的緣故，對每一種數(shù)據(jù)項類型都需要定義各自的鏈表結(jié)構(gòu)。有經(jīng)驗的C++程序員應(yīng)該知道，標(biāo)準(zhǔn)模板庫中的<list>采用的是C++ Template，利用模板抽象出和數(shù)據(jù)項類型無關(guān)的鏈表操作接口。

在Linux內(nèi)核鏈表中，需要用鏈表組織起來的數(shù)據(jù)通常會包含一個struct list_head成員，例如在[include/linux/netfilter.h]中定義了一個nf_sockopt_ops結(jié)構(gòu)來描述Netfilter為某一協(xié)議族準(zhǔn)備的getsockopt/setsockopt接口，其中就有一個（struct list_head list）成員，各個協(xié)議族的nf_sockopt_ops結(jié)構(gòu)都通過這個list成員組織在一個鏈表中，表頭是定義在[net/core/netfilter.c]中的nf_sockopts（struct list_head）。從下圖中我們可以看到，這種通用的鏈表結(jié)構(gòu)避免了為每個數(shù)據(jù)項類型定義自己的鏈表的麻煩。Linux的簡捷實用、不求完美和標(biāo)準(zhǔn)的風(fēng)格，在這里體現(xiàn)得相當(dāng)充分。

三、 鏈表操作接口

1. 聲明和初始化

實際上Linux只定義了鏈表節(jié)點，并沒有專門定義鏈表頭，那么一個鏈表結(jié)構(gòu)是如何建立起來的呢？讓我們來看看LIST_HEAD()這個宏：

#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)

當(dāng)我們用LIST_HEAD(nf_sockopts)聲明一個名為nf_sockopts的鏈表頭時，它的next、prev指針都初始化為指向自己，這樣，我們就有了一個空鏈表，因為Linux用頭指針的next是否指向自己來判斷鏈表是否為空：

static inline int list_empty(const struct list_head *head)
{
		return head->next == head;
}

除了用LIST_HEAD()宏在聲明的時候初始化一個鏈表以外，Linux還提供了一個INIT_LIST_HEAD宏用于運行時初始化鏈表：

#define INIT_LIST_HEAD(ptr) do { \
	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

我們用INIT_LIST_HEAD(&nf_sockopts)來使用它。

2. 插入/刪除/合并

a) 插入

對鏈表的插入操作有兩種：在表頭插入和在表尾插入。Linux為此提供了兩個接口：

static inline void list_add(struct list_head *new, struct list_head *head);
static inline void list_add_tail(struct list_head *new, struct list_head *head);

因為Linux鏈表是循環(huán)表，且表頭的next、prev分別指向鏈表中的第一個和最末一個節(jié)點，所以，list_add和list_add_tail的區(qū)別并不大，實際上，Linux分別用

__list_add(new, head, head->next);

和

__list_add(new, head->prev, head);

來實現(xiàn)兩個接口，可見，在表頭插入是插入在head之后，而在表尾插入是插入在head->prev之后。

假設(shè)有一個新nf_sockopt_ops結(jié)構(gòu)變量new_sockopt需要添加到nf_sockopts鏈表頭，我們應(yīng)當(dāng)這樣操作：

list_add(&new_sockopt.list, &nf_sockopts);

從這里我們看出，nf_sockopts鏈表中記錄的并不是new_sockopt的地址，而是其中的list元素的地址。如何通過鏈表訪問到new_sockopt呢？下面會有詳細(xì)介紹。

b) 刪除

static inline void list_del(struct list_head *entry);

當(dāng)我們需要刪除nf_sockopts鏈表中添加的new_sockopt項時，我們這么操作：

list_del(&new_sockopt.list);

被剔除下來的new_sockopt.list，prev、next指針分別被設(shè)為LIST_POSITION2和LIST_POSITION1兩個特殊值，這樣設(shè)置是為了保證不在鏈表中的節(jié)點項不可訪問--對LIST_POSITION1和LIST_POSITION2的訪問都將引起頁故障。與之相對應(yīng)，list_del_init()函數(shù)將節(jié)點從鏈表中解下來之后，調(diào)用LIST_INIT_HEAD()將節(jié)點置為空鏈狀態(tài)。

c) 搬移

Linux提供了將原本屬于一個鏈表的節(jié)點移動到另一個鏈表的操作，并根據(jù)插入到新鏈表的位置分為兩類：

static inline void list_move(struct list_head *list, struct list_head *head);
static inline void list_move_tail(struct list_head *list, struct list_head *head);

例如list_move(&new_sockopt.list,&nf_sockopts)會把new_sockopt從它所在的鏈表上刪除，并將其再鏈入nf_sockopts的表頭。

d) 合并

除了針對節(jié)點的插入、刪除操作，Linux鏈表還提供了整個鏈表的插入功能：

static inline void list_splice(struct list_head *list, struct list_head *head);

假設(shè)當(dāng)前有兩個鏈表，表頭分別是list1和list2（都是struct list_head變量），當(dāng)調(diào)用list_splice(&list1,&list2)時，只要list1非空，list1鏈表的內(nèi)容將被掛接在list2鏈表上，位于list2和list2.next（原list2表的第一個節(jié)點）之間。新list2鏈表將以原list1表的第一個節(jié)點為首節(jié)點，而尾節(jié)點不變。如圖（虛箭頭為next指針）：

當(dāng)list1被掛接到list2之后，作為原表頭指針的list1的next、prev仍然指向原來的節(jié)點，為了避免引起混亂，Linux提供了一個list_splice_init()函數(shù)：

static inline void list_splice_init(struct list_head *list, struct list_head *head);
	

該函數(shù)在將list合并到head鏈表的基礎(chǔ)上，調(diào)用INIT_LIST_HEAD(list)將list設(shè)置為空鏈。

3. 遍歷

遍歷是鏈表最經(jīng)常的操作之一，為了方便核心應(yīng)用遍歷鏈表，Linux鏈表將遍歷操作抽象成幾個宏。在介紹遍歷宏之前，我們先看看如何從鏈表中訪問到我們真正需要的數(shù)據(jù)項。

a) 由鏈表節(jié)點到數(shù)據(jù)項變量

我們知道，Linux鏈表中僅保存了數(shù)據(jù)項結(jié)構(gòu)中l(wèi)ist_head成員變量的地址，那么我們?nèi)绾瓮ㄟ^這個list_head成員訪問到作為它的所有者的節(jié)點數(shù)據(jù)呢？Linux為此提供了一個list_entry(ptr,type,member)宏，其中ptr是指向該數(shù)據(jù)中l(wèi)ist_head成員的指針，也就是存儲在鏈表中的地址值，type是數(shù)據(jù)項的類型，member則是數(shù)據(jù)項類型定義中l(wèi)ist_head成員的變量名，例如，我們要訪問nf_sockopts鏈表中首個nf_sockopt_ops變量，則如此調(diào)用：

list_entry(nf_sockopts->next, struct nf_sockopt_ops, list);

這里"list"正是nf_sockopt_ops結(jié)構(gòu)中定義的用于鏈表操作的節(jié)點成員變量名。

list_entry的使用相當(dāng)簡單，相比之下，它的實現(xiàn)則有一些難懂：

#define list_entry(ptr, type, member) container_of(ptr, type, member)
container_of宏定義在[include/linux/kernel.h]中：
#define container_of(ptr, type, member) ({			\
        const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
        (type *)( (char *)__mptr - offsetof(type,member) );})
offsetof宏定義在[include/linux/stddef.h]中：
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

size_t最終定義為unsigned int（i386）。

這里使用的是一個利用編譯器技術(shù)的小技巧，即先求得結(jié)構(gòu)成員在與結(jié)構(gòu)中的偏移量，然后根據(jù)成員變量的地址反過來得出屬主結(jié)構(gòu)變量的地址。

container_of()和offsetof()并不僅用于鏈表操作，這里最有趣的地方是((type *)0)->member，它將0地址強制"轉(zhuǎn)換"為type結(jié)構(gòu)的指針，再訪問到type結(jié)構(gòu)中的member成員。在container_of宏中，它用來給typeof()提供參數(shù)（typeof()是gcc的擴展，和sizeof()類似），以獲得member成員的數(shù)據(jù)類型；在offsetof()中，這個member成員的地址實際上就是type數(shù)據(jù)結(jié)構(gòu)中member成員相對于結(jié)構(gòu)變量的偏移量。

如果這么說還不好理解的話，不妨看看下面這張圖：

對于給定一個結(jié)構(gòu)，offsetof(type,member)是一個常量，list_entry()正是利用這個不變的偏移量來求得鏈表數(shù)據(jù)項的變量地址。

b) 遍歷宏

在[net/core/netfilter.c]的nf_register_sockopt()函數(shù)中有這么一段話：

		……
struct list_head *i;
……
	list_for_each(i, &nf_sockopts) {
		struct nf_sockopt_ops *ops = (struct nf_sockopt_ops *)i;
		……
	}
	……
	

函數(shù)首先定義一個(struct list_head *)指針變量i，然后調(diào)用list_for_each(i,&nf_sockopts)進行遍歷。在[include/linux/list.h]中，list_for_each()宏是這么定義的：

        	#define list_for_each(pos, head) \
	for (pos = (head)->next, prefetch(pos->next); pos != (head); \
        	pos = pos->next, prefetch(pos->next))
        	

它實際上是一個for循環(huán)，利用傳入的pos作為循環(huán)變量，從表頭head開始，逐項向后（next方向）移動pos，直至又回到head（prefetch()可以不考慮，用于預(yù)取以提高遍歷速度）。

那么在nf_register_sockopt()中實際上就是遍歷nf_sockopts鏈表。為什么能直接將獲得的list_head成員變量地址當(dāng)成struct nf_sockopt_ops數(shù)據(jù)項變量的地址呢？我們注意到在struct nf_sockopt_ops結(jié)構(gòu)中，list是其中的第一項成員，因此，它的地址也就是結(jié)構(gòu)變量的地址。更規(guī)范的獲得數(shù)據(jù)變量地址的用法應(yīng)該是：

struct nf_sockopt_ops *ops = list_entry(i, struct nf_sockopt_ops, list);

大多數(shù)情況下，遍歷鏈表的時候都需要獲得鏈表節(jié)點數(shù)據(jù)項，也就是說list_for_each()和list_entry()總是同時使用。對此Linux給出了一個list_for_each_entry()宏：

#define list_for_each_entry(pos, head, member)		……

與list_for_each()不同，這里的pos是數(shù)據(jù)項結(jié)構(gòu)指針類型，而不是(struct list_head *)。nf_register_sockopt()函數(shù)可以利用這個宏而設(shè)計得更簡單：

……
struct nf_sockopt_ops *ops;
list_for_each_entry(ops,&nf_sockopts,list){
	……
}
……

某些應(yīng)用需要反向遍歷鏈表，Linux提供了list_for_each_prev()和list_for_each_entry_reverse()來完成這一操作，使用方法和上面介紹的list_for_each()、list_for_each_entry()完全相同。

如果遍歷不是從鏈表頭開始，而是從已知的某個節(jié)點pos開始，則可以使用list_for_each_entry_continue(pos,head,member)。有時還會出現(xiàn)這種需求，即經(jīng)過一系列計算后，如果pos有值，則從pos開始遍歷，如果沒有，則從鏈表頭開始，為此，Linux專門提供了一個list_prepare_entry(pos,head,member)宏，將它的返回值作為list_for_each_entry_continue()的pos參數(shù)，就可以滿足這一要求。

4. 安全性考慮

在并發(fā)執(zhí)行的環(huán)境下，鏈表操作通常都應(yīng)該考慮同步安全性問題，為了方便，Linux將這一操作留給應(yīng)用自己處理。Linux鏈表自己考慮的安全性主要有兩個方面：

a) list_empty()判斷

基本的list_empty()僅以頭指針的next是否指向自己來判斷鏈表是否為空，Linux鏈表另行提供了一個list_empty_careful()宏，它同時判斷頭指針的next和prev，僅當(dāng)兩者都指向自己時才返回真。這主要是為了應(yīng)付另一個cpu正在處理同一個鏈表而造成next、prev不一致的情況。但代碼注釋也承認(rèn)，這一安全保障能力有限：除非其他cpu的鏈表操作只有l(wèi)ist_del_init()，否則仍然不能保證安全，也就是說，還是需要加鎖保護。

b) 遍歷時節(jié)點刪除

前面介紹了用于鏈表遍歷的幾個宏，它們都是通過移動pos指針來達到遍歷的目的。但如果遍歷的操作中包含刪除pos指針?biāo)赶虻墓?jié)點，pos指針的移動就會被中斷，因為list_del(pos)將把pos的next、prev置成LIST_POSITION2和LIST_POSITION1的特殊值。

當(dāng)然，調(diào)用者完全可以自己緩存next指針使遍歷操作能夠連貫起來，但為了編程的一致性，Linux鏈表仍然提供了兩個對應(yīng)于基本遍歷操作的"_safe"接口：list_for_each_safe(pos, n, head)、list_for_each_entry_safe(pos, n, head, member)，它們要求調(diào)用者另外提供一個與pos同類型的指針n，在for循環(huán)中暫存pos下一個節(jié)點的地址，避免因pos節(jié)點被釋放而造成的斷鏈。

四、 擴展

1. hlist

精益求精的Linux鏈表設(shè)計者（因為list.h沒有署名，所以很可能就是Linus Torvalds）認(rèn)為雙頭（next、prev）的雙鏈表對于HASH表來說"過于浪費"，因而另行設(shè)計了一套用于HASH表應(yīng)用的hlist數(shù)據(jù)結(jié)構(gòu)--單指針表頭雙循環(huán)鏈表，從上圖可以看出，hlist的表頭僅有一個指向首節(jié)點的指針，而沒有指向尾節(jié)點的指針，這樣在可能是海量的HASH表中存儲的表頭就能減少一半的空間消耗。

因為表頭和節(jié)點的數(shù)據(jù)結(jié)構(gòu)不同，插入操作如果發(fā)生在表頭和首節(jié)點之間，以往的方法就行不通了：表頭的first指針必須修改指向新插入的節(jié)點，卻不能使用類似list_add()這樣統(tǒng)一的描述。為此，hlist節(jié)點的prev不再是指向前一個節(jié)點的指針，而是指向前一個節(jié)點（可能是表頭）中的next（對于表頭則是first）指針（struct list_head **pprev），從而在表頭插入的操作可以通過一致的"*(node->pprev)"訪問和修改前驅(qū)節(jié)點的next（或first）指針。

2. read-copy update

在Linux鏈表功能接口中還有一系列以"_rcu"結(jié)尾的宏，與以上介紹的很多函數(shù)一一對應(yīng)。RCU（Read-Copy Update）是2.5/2.6內(nèi)核中引入的新技術(shù)，它通過延遲寫操作來提高同步性能。

我們知道，系統(tǒng)中數(shù)據(jù)讀取操作遠(yuǎn)多于寫操作，而rwlock機制在smp環(huán)境下隨著處理機增多性能會迅速下降（見參考資料4）。針對這一應(yīng)用背景，IBM Linux技術(shù)中心的Paul E. McKenney提出了"讀拷貝更新"的技術(shù)，并將其應(yīng)用于Linux內(nèi)核中。RCU技術(shù)的核心是寫操作分為寫-更新兩步，允許讀操作在任何時候無阻訪問，當(dāng)系統(tǒng)有寫操作時，更新動作一直延遲到對該數(shù)據(jù)的所有讀操作完成為止。Linux鏈表中的RCU功能只是Linux RCU的很小一部分，對于RCU的實現(xiàn)分析已超出了本文所及，有興趣的讀者可以自行參閱本文的參考資料；而對RCU鏈表的使用和基本鏈表的使用方法基本相同。

五、 示例

附件中的程序除了能正向、反向輸出文件以外，并無實際作用，僅用于演示Linux鏈表的使用。

為了簡便，例子采用的是用戶態(tài)程序模板，如果需要運行，可采用如下命令編譯：

gcc -D__KERNEL__ -I/usr/src/linux-2.6.7/include pfile.c -o pfile

因為內(nèi)核鏈表限制在內(nèi)核態(tài)使用，但實際上對于數(shù)據(jù)結(jié)構(gòu)本身而言并非只能在核態(tài)運行，因此，在筆者的編譯中使用"-D__KERNEL__"開關(guān)"欺騙"編譯器。

參考資料

1. 維基百科 http://zh.wikipedia.org，一個在GNU Documentation License下發(fā)布的網(wǎng)絡(luò)辭典，自由軟件理念的延伸，本文的"鏈表"概念即使用它的版本。
2. 《Linux內(nèi)核情景分析》，毛德操先生的這本關(guān)于Linux內(nèi)核的巨著幾乎可以回答絕大部分關(guān)于內(nèi)核的問題，其中也包括內(nèi)核鏈表的幾個關(guān)鍵數(shù)據(jù)結(jié)構(gòu)。
3. Linux內(nèi)核2.6.7源代碼，所有不明白的問題，只要潛心看代碼，總能清楚。
4. Kernel Korner: Using RCU in the Linux 2.5 Kernel，RCU主要開發(fā)者Paul McKenney 2003年10月發(fā)表于Linux Journal上的一篇介紹RCU的文章。在 http://www.rdrop.com/users/paulmck/rclock/上可以獲得更多關(guān)于RCU的幫助。

關(guān)于作者

進程在退出時，必須釋放它所擁有的資源，并通過某種方式告訴父進程。進程的退出一般是顯示或隱式地調(diào)用了eixt(),或者接受了某種信號。不過什么原因退出，最終都調(diào)用了do_exit。

用于進程退出的系統(tǒng)調(diào)用有兩個exit和exit_group，exit只是終止某個進程，而exit_group整個線程中的進程。它們在內(nèi)核中的服務(wù)函數(shù)分別為sys_exit和sys_exit_group，它們又分別調(diào)用了do_exit和do_group_exit。而do_group最終又調(diào)用了do_exit。

do_exit定義在kernel/exit.c中：

僵死進程：僵死進程是一個進程已經(jīng)退出，它的內(nèi)存和資源已經(jīng)釋放掉了，但是位了時系統(tǒng)在它退出后能夠獲得它的退出狀態(tài)等信息，它的進程描述符仍然保留。

一個進程退出時，它的父進程會接收到一個SIGCHLD信號，一般情況下這個信號的處理函數(shù)會執(zhí)行wait系列函數(shù)等待子進程的結(jié)束。從子進程退出到父進程調(diào)用wait(子進程結(jié)束)的這段時間，子進程稱為僵死進程。執(zhí)行ps –ef命令以“z”結(jié)尾的為僵死進程。

僵死進程很特殊，它沒有任何可執(zhí)行代碼，不會被調(diào)度，只有一個進程描述符用來記錄退出等狀態(tài)，除此之外不再占用其他任何資源。

如果僵死進程的父進程沒有調(diào)用wait，則該進程會一直處于僵死狀態(tài)。如果父進程結(jié)束，內(nèi)核會在當(dāng)前線程組里為其找一個父進程，如果沒找到則把init作為其父進程，此時新的父進程將負(fù)責(zé)清楚其進程。如果父進程一直不結(jié)束，該進程會一直僵死。在root下用kill -9 也不能將其殺死。

下面只對do_exit重點地方解析下： 

1. struct task_struct *tsk = current;//獲取當(dāng)前要釋放進程的進程描述符   
   

   
   exit_signals(tsk);  /* sets PF_EXITING 以免內(nèi)和其他部分訪問該進程*/   
   
   exit_mm(tsk);  
2.   
3.     if (group_dead)  
4.         acct_process();  
5.     trace_sched_process_exit(tsk);  
6.   
7.     exit_sem(tsk);  
8.     exit_files(tsk);  
9.     exit_fs(tsk);  
10.     check_stack_usage();  
    
    
11. /*更新父子關(guān)系，并告訴父進程正在退出*/  
12.     exit_notify(tsk, group_dead);
13. /*切換到其他進程*/  
14.     schedule(); 
15.     exit_thread();  
    
    
    

    第1個Child process 6427, data 10是因為子進程創(chuàng)建時task_struct的mm直接拷貝自parent的mm；第2個Child process 6427, data 20是因為子進程進行了“寫時拷貝”，有了自己的dataa；第3個Parent process 6426, data 10輸出10是因為子進程的data和父進程的data不是同一份。
    如果把上述程序改為：

一、Observer模式的意圖：

                在對象的內(nèi)部狀態(tài)發(fā)生變化時，自動通知外部對象進行響應(yīng)。

二、Observer模式的構(gòu)成：

               ·被觀察者：內(nèi)部狀態(tài)有可能被改變，而且又需要通知外部的對象

               ·觀察者：需要對內(nèi)部狀態(tài)的改變做出響應(yīng)的對象

三、Observer模式的Java實現(xiàn)：

                Java的API中已經(jīng)為我們提供了Observer模式的實現(xiàn)。具體由java.util.Observable類和java.util.Observer接口完成。

                前者有兩個重要的方法：

                       ·setChanged：設(shè)置內(nèi)部狀態(tài)為已改變

                       ·notifyObservers(Object obj)：通知觀察者所發(fā)生的改變，參數(shù)obj是一些改變的信息

                后者有一個核心方法：

                       ·update(Object obj)：相應(yīng)被觀察者的改變，其中obj就是被觀察者傳遞過來的信息，該方法會在notifyObservers被調(diào)用時自動調(diào)用。

              下面是Observer模式的實現(xiàn)過程：

                     ·創(chuàng)建一個被觀察者，繼承java.util.Observable

                     ·創(chuàng)建一個觀察者，實現(xiàn)java.util.Observer接口

                    · 注冊觀察著，調(diào)用addObserver(Observer observer)

                    ·在被觀察者改變對象內(nèi)部狀態(tài)的地方，調(diào)用setChanged()方法，然后調(diào)用notifyObservers(Object)方法，通知被觀察者

                   ·在觀察者的update(Object)方法中，對改變做出響應(yīng)。

四、Observer模式的好處：

                 1.Observer模式的優(yōu)點：

                       ·被觀察者只需要知道誰在觀察它，無需知道具體的觀察細(xì)節(jié)

                       ·被觀察者一旦發(fā)生變化，只需要通過廣播的方式告知觀察者，至于消息如何到達則不需知道。這樣的話無疑消除了被觀察者和觀察者之間通信的硬編碼

                       ·當(dāng)一個被觀察者同時被多個觀察著觀察時，觀察者可以只選擇自己感興趣的事件，而忽略其它的事件
   
                      ·多個觀察者組合起來可以形成一個觀察鏈，如果一旦需要回滾多個操作，此時觀察鏈可以發(fā)揮作用

                      ·觀察者可以實時對被觀察對象的變化做出響應(yīng)，例如自動告警、中斷運行等

                2.運用Observer模式可以

                     ·屏蔽線程間的通信機制：例如兩個線程之間，主線程可以作為觀察者，執(zhí)行線程是被觀察者。彼此之間只知道對方存在，但不知道之間通信的細(xì)節(jié)

                    ·消除硬編碼：如果沒有Observer模式，則只能采用回調(diào)的模式，或者在代碼中顯示地調(diào)用觀察者

                    ·優(yōu)化異常機制：特別適合在異常發(fā)生時向頂層監(jiān)控，減少try-catch代碼量

代碼：