1. 什么是completions机制？

在内核编程中常有这样的场景，在当前线程中创建一个线程，并且等待它完成之后再继续执行。通常可以用信号量来解决它，也可以用completion机制来解决。

2. 为什么用completions ，它比信号量好在哪？

使用completion比使用信号量简单。

使用completion可以一次性唤醒所有等待进程，而用信号量会比较麻烦。

 The basic summary is that we had this (fairly common) way of waiting for certain events by having a locked semaphore on the stack of the waiter, and then having the waiter do a "down()" which caused it to block until the thing it was waiting for did an "up()".

This works fairly well, but it has a really small (and quite unlikely) race on SMP, that is not so much a race of the idea itself, as of the implementation of the semaphores. We could have fixed the semaphores, but there were a few reasons not to:

• the semaphores are optimized (on purpose) for the non-contention case. The "wait for completion" usage has the opposite default case
• the semaphores are quite involved and architecture-specific, exactly
  due to this optimization. Trying to change them is painful as hell.

struct semaphore sem;

init_MUTEX_LOCKED(&sem);
start_external_task(&sem);
down(&sem);

3. 怎么用completions？

 

/*
 * Completions 目前使用先进先出的队列来存放等待‘completion’的事件
 */
struct completion {
        unsigned int done;
        wait_queue_head_t wait;
};

 

    
    (1) 定义completion
        struct completion my_completion;
    (2) 初始化completion
        init_completion(&my_completion);/*动态创建一个completion*/
		
        DECLEARE_COMPLETION(my_completion);/*（包含定义）静态初始化completion*/
		
    (3) 等待completion
	/*This waits to be signaled for completion of a specific task. It is NOT interruptible and there is no timeout.*/
	void wait_for_completion(struct completion *c);
	/*This waits for completion of a specific task to be signaled. It is interruptible.*/
	int wait_for_completion_interruptible(struct completion *x); 
	/*This waits to be signaled for completion of a specific task. It can be
	* interrupted by a kill signal.
	*/
	int wait_for_completion_killable(struct completion *x);
		
	/*This waits for either a completion of a specific task to be signaled or for a
	* specified timeout to expire. The timeout is in jiffies. It is not
	* interruptible.
	*/
	unsigned long wait_for_completion_timeout(struct completion *x,
							   unsigned long timeout);
	/** This waits for either a completion of a specific task to be signaled or for a
	* specified timeout to expire. It is interruptible. The timeout is in jiffies.
	*/
	long wait_for_completion_interruptible_timeout(
				struct completion *x, unsigned long timeout);
	/*This waits for either a completion of a specific task to be
	* signaled or for a specified timeout to expire. It can be
	* interrupted by a kill signal. The timeout is in jiffies.
	*/
	long wait_for_completion_killable_timeout(
				struct completion *x, unsigned long timeout);
    (4) 唤醒completion
        void complete(struct completion *c);/*唤醒一个等待的Thread*/
        void complete_all(struct completion *c);/*唤醒所有等待此completion的Threads*/

[1] http://stackoverflow.com/questions/4764945/difference-between-completion-variables-and-semaphores

[2] http://www.makelinux.net/ldd3/chp-5-sect-4

[3] http://blog.csdn.net/dreamxu/article/details/5866593