2. 程式人生 > >IO 的阻塞和非阻塞一：等待佇列

IO 的阻塞和非阻塞一：等待佇列

阿新 • • 發佈：2019-02-04
阻塞操作是指在執行裝置操作時，若不能獲得資源，則掛起程序直到滿足可操作的條件後再 進行操作。被掛起的程序進入休眠狀態，被從排程器的執行佇列移走，直到等待的條件被滿足。 阻塞，預設的形式簡單直接效率低 非阻塞，相反，佔用資源比較多 阻塞從字面上聽起來似乎意味著低效率，實則不然，如果裝置驅動不阻塞，則使用者想獲取設 備資源只能不停地查詢，這反而會無謂地耗費 CPU 資源。而阻塞訪問時，不能獲取資源的程序將 進入休眠，它將 CPU 資源“禮讓”給其他程序。 介紹：以佇列為基礎資料結構，與程序排程機制緊密結合，能夠用於實現核心中的非同步事件通知機制，也可以用來同步對系統資源的訪問。 注意：雖然說的是佇列，但不是 fifo，沒有 fifo 的特性

1. 等待佇列： -- wait queue

在 Linux 驅動程式中，可以使用等待佇列（wait queue）來實現阻塞程序的喚醒。它以佇列為基礎資料結構，與程序排程機制緊密結合，能夠用於實現核心中的非同步事件通知機制。等待佇列可以用來同步對系統資源的訪問，訊號量在核心中依賴等待佇列來實現。 定義
“等待佇列頭”
wait_queue_head_t my_queue;
初始化“等待佇列頭”
init_waitqueue_head(&my_queue);
而下面的 DECLARE_WAIT_QUEUE_HEAD()巨集可以作為定義並初始化等待佇列頭的“快捷方式”。
DECLARE_WAIT_QUEUE_HEAD (name)
定義等待佇列
DECLARE_WAITQUEUE(name, tsk)
該巨集用於定義並初始化一個名為 name 的等待佇列。 新增/移除等待佇列
void fastcall add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait); void fastcall remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
add_wait_queue()用於將等待佇列 wait 新增到等待佇列頭 q 指向的等待佇列連結串列中，而remove_wait_queue()用於將等待佇列 wait 從附屬的等待佇列頭 q 指向的等待佇列連結串列中移除。 等待事件
wait_event(wait_queue_head_t queue, condition) --> 深睡，不可以被訊號打斷 wait_event_interruptible(wait_queue_head_t queue, condition) --> 淺睡，可以被訊號打斷 wait_event_timeout(wait_queue_head_t queue, condition, timeout) wait_event_interruptible_timeout(wait_queue_head_t queue, condition, timeout)
queue，作為等待佇列頭的等待佇列被喚醒
condition，條件，滿足 喚醒，否則 阻塞
timeout，阻塞等待的超時時間，單位是 jiffy，等待時間 timeout 後，無論條件滿足不滿足，都返回
喚醒佇列
void wake_up(wait_queue_head_t *queue); void wake_up_interruptible(wait_queue_head_t *queue);
喚醒時會判斷 condition ①wake_up() -- wait_event() / wait_event_timeout() ②wake_up_interruptible() -- wait_event_interruptible() / wait_event_interruptible_timeout() ①可以喚醒處於 TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE 的程序 ②可以喚醒處於 TASK_INTERRUPTIBLE 的程序 在等待佇列上睡眠：
sleep_on(wait_queue_head_t *q); interruptible_sleep_on(wait_queue_head_t *q); 
sleep_on 將目前程序的狀態置成 TASK_UNINTERRUPTIBLE，並定義一個等待佇列，之後把它附屬到等待佇列頭 q，直到資源可獲得，q 引導的等待佇列被喚醒。 wake_up_interruptible將目前程序的狀態置成 TASK_ INTERRUPTIBLE，並定義一個等待佇列，之後把它附屬到等待佇列頭q，直到資源可獲得，q引導的等待佇列被喚醒或者程序收到訊號。 sleep_on()函式應該與 wake_up()成對使用，interruptible_sleep_on()應該wake_up_interruptible() 成對使用。 注意：
在許多裝置驅動中，並不呼叫 sleep_on()或 interruptible_sleep_on()，而是親自進行程序的狀態改變和切換

2. 例子

為了讓 驅動支援 阻塞和非阻塞，需要在驅動中使用等待佇列：

waitqueue.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/sched.h>
#include <linux/semaphore.h>
#include <linux/device.h>

MODULE_LICENSE ("GPL");

int hello_major = 250;
int hello_minor = 0;
int number_of_devices = 1;
struct class *my_class;

struct hello_device
{
    char data[128];
    int len;
    wait_queue_head_t rq, wq;
    struct semaphore sem;
    struct cdev cdev;
} hello_device;

static int hello_open (struct inode *inode, struct file *filp)
{
    filp->private_data = container_of(inode->i_cdev, struct hello_device, cdev);
    printk (KERN_INFO "Hey! device opened\n");
    printk (KERN_INFO "len = %d\n",(*((int *)filp->private_data)));

    return 0;
}

static int hello_release (struct inode *inode, struct file *filp)
{
    printk (KERN_INFO "Hmmm... device closed\n");

    return 0;
}

ssize_t hello_read (struct file *filp, char *buff, size_t count, loff_t *offp)
{
    ssize_t result = 0;
    struct hello_device *dev = filp->private_data;

    down(&dev->sem);
    while (hello_device.len == 0)
    {
        up(&dev->sem);
        if (filp->f_flags & O_NONBLOCK)
            return -EAGAIN;
        if (wait_event_interruptible(dev->rq, (dev->len != 0))) return -ERESTARTSYS;
        down(&dev->sem);
    }

    if (count > dev->len) count = dev->len;
    if (copy_to_user (buff, dev->data, count)) 
    {   
        result = -EFAULT;
    }
    else
    {
        printk (KERN_INFO "read %d bytes\n", (int)count);
        dev->len -= count;
        result = count;
        memcpy(dev->data, dev->data+count, dev->len);
    }
    up(&dev->sem);
    wake_up(&dev->wq);

    return result;
}

ssize_t hello_write (struct file *filp, const char  *buf, size_t count, loff_t *f_pos)
{
    ssize_t ret = 0;
    struct hello_device *dev = filp->private_data;

    if (count > 128) return -ENOMEM;
    down(&dev->sem);
    while (dev->len == 128)
    {
        up(&dev->sem);
        if (filp->f_flags & O_NONBLOCK)
            return -EAGAIN;
        if (wait_event_interruptible(dev->wq, (dev->len != 128))) return -ERESTARTSYS;
        down(&dev->sem);
    }

    if (count > (128 - dev->len)) count = 128 - dev->len;
    if (copy_from_user (dev->data+dev->len, buf, count)) {
        ret = -EFAULT;
    }
    else {
        printk (KERN_INFO "write %d bytes\n", (int)count);
        dev->len += count;
        ret = count;
    }
    up(&dev->sem);
    wake_up(&dev->rq);

    return ret;
}

struct file_operations hello_fops = {
    .owner = THIS_MODULE,
    .open  = hello_open,
    .release = hello_release,
    .read  = hello_read,
    .write = hello_write
};

static void char_reg_setup_cdev (void)
{
    int error;
    dev_t devno;

    devno = MKDEV (hello_major, hello_minor);
    cdev_init (&hello_device.cdev, &hello_fops);
    hello_device.cdev.owner = THIS_MODULE;
    error = cdev_add (&hello_device.cdev, devno , 1);
    if (error)
        printk (KERN_NOTICE "Error %d adding char_reg_setup_cdev", error);
}

static int char_dev_create (void)
{
    my_class = class_create(THIS_MODULE,"waitqueue_class");
    if(IS_ERR(my_class)) 
    {
        printk("Err: failed in creating class.\n");
        return -1; 
    }
    device_create(my_class, NULL, MKDEV (hello_major, hello_minor), NULL, "waitqueue");

    return 0;
}

static int __init hello_2_init (void)
{
    int result;
    dev_t devno;

    devno = MKDEV (hello_major, hello_minor);
    result = register_chrdev_region (devno, number_of_devices, "waitqueue");

    if (result < 0) {
        printk (KERN_WARNING "hello: can't get major number %d\n", hello_major);
        goto err1;
    }

    char_dev_create();
    char_reg_setup_cdev ();
    init_waitqueue_head(&hello_device.rq);
    init_waitqueue_head(&hello_device.wq);
    sema_init(&hello_device.sem, 1);
    memset(hello_device.data, 0, 128);
    hello_device.len = 0;

    printk (KERN_INFO "char device registered\n");

    return 0;

err1:
    device_destroy(my_class, devno);
    class_destroy(my_class);
    unregister_chrdev_region(devno, 1);

    return result;
}

static void __exit hello_2_exit (void)
{
    dev_t devno = MKDEV (hello_major, hello_minor);
    cdev_del (&hello_device.cdev);
    device_destroy(my_class, devno);         //delete device node under /dev//必須先刪除裝置，再刪除class類
    class_destroy(my_class);                 //delete class created by us
    unregister_chrdev_region (devno, number_of_devices);
    printk("waitqueue module exit \n");
    return;
}

module_init (hello_2_init);
module_exit (hello_2_exit);

test_write.c 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

#define N 90

int main()
{
    int i, fd;
    char buf[N];

    for (i=0; i<90; i++) 
    {
        buf[i] = i + 33;
    }

    if ((fd = open("/dev/waitqueue", O_WRONLY)) < 0)
    {
        perror("fail to open");
    }
    printf("wrote %d bytes\n", (int)write(fd, buf, N));
    close(fd);

    return 0;
}

test_read.c 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

#define N 90

int main()
{
    int i, fd;
    char buf[N] = {0};
    int num = 0;

    if ((fd = open("/dev/waitqueue", O_RDWR)) < 0)
    {
        perror("fail to open");
        return -1;

    }
    puts("open is ok");
    if((num = read(fd, buf, 10)) < 0)
    {
        printf("num = %d \n", num);
        perror("read:");

    }
    printf("read num = %d \n", num);
    printf("Is:");
    puts(buf);

    close(fd);

    return 0;
}

Makefile 
ifeq ($(KERNELRELEASE),)

KERNELDIR ?= /lib/modules/$(shell uname -r)/build 
#KERNELDIR ?= ~/wor_lip/linux-3.4.112
PWD := $(shell pwd)

modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install

clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules* Module*

.PHONY: modules modules_install clean

else
	obj-m := waitqueue.o
endif

程式思路：
①在驅動中的讀和寫的方法中分別判斷 filp->f_flags 是不是 O_NONBLOCK ，如果標誌是非阻塞，就馬上返回， ②在讀和寫的方法中還要加上訊號量實現 PV 操作，防止多個函式讀的時候出現混亂的情況 ③在條件不滿足(讀的時候，緩衝區中內容長度 = 0.寫的時候緩衝區長度 = 128)呼叫相應的讀寫等待佇列
程式的功能：
寫函式一次寫 90 個字元， 讀函式每次只讀 10 個字元，
如果讀了很多次，讀完了 buf 中的內容，就會阻塞的等在哪裡，開啟另外的客戶端，進行寫操作，讀客戶端在寫完的剎那，能夠讀出資料 在有 A 客戶端讀完了，並且處於阻塞狀態，再開一個 B 客戶端依然讀阻塞，在 C 客戶端進行寫的時候，寫完後，A 客戶端會先得到資料， B 再得到資料

相關推薦

IO 的阻塞和非阻塞一：等待佇列

阻塞操作是指在執行裝置操作時，若不能獲得資源，則掛起程序直到滿足可操作的條件後再 進行操作。被掛起的程序進入休眠狀態，被從排程器的執行佇列移走，直到等待的條件被滿足。 阻塞，預設的形式簡單直接效率低 非阻塞，相反，佔用資源比較多 阻塞從字面上聽起來似乎意味著低效率，實則

談IO中的阻塞和非阻塞，同步和非同步及三種IO模型

什麼是同步和非同步？        燒水，我們都是通過熱水壺來燒水的。在很久之前，科技還沒有這麼發達的時候，如果我們要燒水，需要把水壺放到火爐上，我們通過觀察水壺內的水的沸騰程度來判斷水有沒有燒開。隨著科技的發展，現在市面上的水壺都有了提醒功能，當我們把水壺插電

談IO中的阻塞和非阻塞，同步和異步及三種IO模型

狀態 阻塞io 舉例 最大的 data- str 被調用 當我 返回 什麽是同步和異步？ 燒水，我們都是通過熱水壺來燒水的。在很久之前，科技還沒有這麽發達的時候，如果我們要燒水，需要把水壺放到火爐上，我們通過觀察水壺內的水的沸騰程度來判斷水有沒有燒開。隨著科

網路程式設計Socket的阻塞和非阻塞IO

網路應用程式一個很重要的工作是傳輸資料。傳輸資料的過程不一樣取決於使用哪種“交通工具“，但是傳輸的方式都是一樣的：都是以位元組碼傳輸。JAVA開發網路程式傳輸資料的過程和方式是被抽象了的，我們不需要關注底層介面，只需要使用Java API 或其他網路框架就能達到資料傳輸的目

阻塞和非阻塞，同步和非同步IO及IO多路複用

阻塞和非阻塞，同步和非同步 1 例子 故事：老王燒開水。 出場人物：老張，水壺兩把（普通水壺，簡稱水壺；會響的水壺，簡稱響水壺）。 老王想了想，有好幾種等待方式 1.老王用水壺煮水，並且站在那裡，不管水開沒開，每隔一定時間看看水開了沒。－同步阻塞

linux裝置驅動中的阻塞和非阻塞IO

一、等待佇列 1、定義等待佇列頭 wait_queue_head_t my_queue; 2、初始化等待佇列頭 init_waitqueue_head(&my_queue); 3、定義等待佇列 DECLARE_WAITQUEUE(name,tsk); 4、新增/移除

阻塞和非阻塞、同步和非同步 、五種IO模型

阻塞和非阻塞，同步和非同步1 例子故事：老王燒開水。出場人物：老張，水壺兩把（普通水壺，簡稱水壺；會響的水壺，簡稱響水壺）。老王想了想，有好幾種等待方式1.老王用水壺煮水，並且站在那裡，不管水開沒開，每隔一定時間看看水開了沒。－同步阻塞老王想了想，這種方法不夠聰明。2.老王還

IO復用,AIO,BIO,NIO,同步，異步，阻塞和非阻塞 區別參考

selector 執行器 有意 write lan 關聯 接收 targe ble 參考https://www.cnblogs.com/aspirant/p/6877350.html?utm_source=itdadao&utm_medium=referral

6、阻塞和非阻塞

失敗 解決 實驗 file iostream pac \n std shell 　　讀常規文件是不會阻塞的，不管讀多少字節，read一定會在有限的時間內返回。但是從終端設備或網絡讀則不一定，如果從終端輸入的數據沒有換行符，調用read讀終端設備就會阻塞，如果網絡上沒有接收到

同步異步以及阻塞和非阻塞的區別

結束 線程 同步異步 成功 -s 區別 狀態 得到 概念 一、同步與異步的區別： 同步：一個服務的完成需要依賴其他服務時，只有等待被依賴的服務完成後，才算完成，這是一種可靠的服務序列。要麽成功都成功，失敗都失敗，服務的狀態可以保持一致。 異步：一個服務的完成需要依賴其他

recv send 阻塞和非阻塞

int send( SOCKET s, const char FAR *buf, int len, int flags ); 不論是客戶還是伺服器應用程式都用send函式來向TCP連線的另一端傳送資料。客戶程式一般用send函式向伺服器傳送請求，而伺服器則通常用send函式來向客戶程式傳送應答。

C/C++網路程式設計在windows和linux中將socket設定為阻塞和非阻塞

C/C++網路程式設計在windows和linux中將socket設定為阻塞和非阻塞              在 socket程式設計中，對於socket的讀寫預設都是阻塞的，但有的情況我們需要將其設定為非阻塞，比如做多

什麼是同步和非同步，什麼是阻塞和非阻塞

同步和非同步是針對應用程式和核心的互動而言的，同步指的是使用者程序觸發IO操作並等待或者輪詢的去檢視IO操作是否就緒，而非同步是指使用者程序觸發IO操作以後便開始做自己的事情，而當IO操作已經完成的時候會得到IO完成的通知。 以銀行取款為例： 同步：自己親自出馬持銀行卡到銀行取錢（使用同

阻塞和非阻塞、同步和非同步

阻塞和非阻塞 阻塞呼叫是指呼叫結果返回之前，呼叫者會進入阻塞狀態等待。只有在得到結果之後才會返回。 非阻塞呼叫是指在不能立刻得到結果之前，該函式不會阻塞當前執行緒，而會立刻返回。   2.同步與非同步 同步和非同步關注的是訊息通訊機制 (synchronous c

同步和非同步_阻塞和非阻塞

阻塞和非阻塞 執行緒去請求資源時，遇到資源正在處理還未準備就緒的情況的兩種處理方式： 阻塞：執行緒等待該資源準備就緒。呼叫結果返回之前，當前執行緒會被掛起。 非阻塞：執行緒發現該資源正在處理，會去請求別的資源 同步和非同步 訪問資料的兩種機制： 同步：請求資料時，等

阻塞和非阻塞

在介紹阻塞和非阻塞之前，我們先來了解一下多執行緒間一個重要的概念——臨界區。 臨界區——一種公有的資源或者共享資料，它可以被多個執行緒使用。臨界區資源一次只能被一個執行緒使用，其它執行緒必須等待上一個執行緒 執行完成之後，才能使用。臨界區資源是多執行緒之間

Java-併發-佇列-阻塞和非阻塞佇列總結

Java-併發-佇列-阻塞和非阻塞佇列總結 轉載宣告： 本文系轉載自以下文章： Java 併發 — 阻塞佇列總結 作者： thgreat java中併發集合 作者：hy飛無 0x01 摘要 本文會對java併發包內的常用重要阻塞/非阻塞佇列進行總結。

從 Linux 原始碼看 socket 的阻塞和非阻塞

從linux原始碼看socket的阻塞和非阻塞 筆者一直覺得如果能知道從應用到框架再到作業系統的每一處程式碼，是一件Exciting的事情。 大部分高效能網路框架採用的是非阻塞模式。筆者這次就從linux原始碼的角度來闡述socket阻塞(block)和非阻塞(non_block)的區別。 本文

C#裡面MessageBox不能亂用，阻塞和非阻塞，模態對話方塊和非模態

我一開始以為這個MessageBox跟Delphi裡面的ShowMessage是一樣的，程式裡可以隨便放，因為C#裡面就TM這一個封裝好的彈出對話方塊提示訊息函式，可以直接用的。 結果實習做程式測試被坑爹了，發現我錯了，C#這個MessageBox預設是模態對話方塊，是阻塞的，也就是說你不

python-同步和非同步、阻塞和非阻塞、序列和並行、並行和併發、密集型、執行緒和程序的相關概念

1. 同步和非同步 　　關注的是訊息的通訊機制，描述的是一種行為方式，是多個任務之間的關係。 ① 同步： 呼叫者主動等待被呼叫方返回結果，在沒有返回結果之前，就一直專職等待。 千萬不要把計算機中“同步”理解成“同時執行”。 ② 非同步：呼叫者傳送請求請求，不會專職等待