linux选择填空题
掛載
2.信號是在軟件層次上對()機制的一種模擬， 是一種異步通信方式。
中斷
3.用 GCC 編譯過程可以被細分為四個階段:( )
預處理，編譯，匯編，連接
4.編譯有線程的文件要加( )參數。
-lpthread?
5.父進程等待子進程的結束，可以使用的函數是( )和( )。
?wait( ) waitpid( )
6.linux 主要有兩個信號安裝函數，分別是 signal( ) , sigaction( )
7.Linux 操作系統內核由( )編寫完成。
C 和匯編
8.目錄( )下存放 linux 操作系統啟動時所要用到的程序
/boot
9.Linux 中采用“一對一”的線程機制，也就是一個用戶線程對應一個( )。
內核線程
10.vim 三種模式:在命令模式下按下( )就進入了底線命令模式。
:
11.linux 文件系統由四部分組成，( )用于存放文件的控制信息。
超級塊
12.線程本身調用( )函數可以退出線程。
pthread_exit()
13.向消息隊列發送消息的函數是( )。
msgsnd()
14.( )系統調用可以根據文件描述符來操作文件特性。
fcntl
15.Valgrind 包括很多工具，( )是 valgrind 應用最廣泛的工具，一個重量級的內存檢查器，能 夠發現開發中絕大多數內存錯誤使用情況，( )是主要用來檢查程序中緩存使用出現的問題。 Memcheck，Cachegrind
16.信號發送函數中，( )用于設置定時器，當計時時間到達時，向進程發送 SIGALRM 信號。 setitimer()
17.當一個線程的屬性設置為( )，該線程結束時立即釋放它所占有的系統資源。
分離狀態
18.以下哪種方式屬于異常終止一個進程(D)
D.接到一個信號并終止。
19.下列命令哪個是創建線程私有數據命令(A)
A.pthread_key_create()
20.下面哪種通信方式適用于不同機器之間的進程通信。(D )
套接字
21.創建或打開消息隊列的函數為(A )
msgget()
22.linux 中通過調用 waitpid()函數得到進程的退出信息，該函數原型為 pid_t waitpid(pit_t pid, int *statloc, int options);當第一個參數 pid 取值為-1 時，表示(A)
A 等待任一子進程退出,相當于 wait()。
23.Linux 環境中使用 kill 函數向進程或進程組發送信號。Kill 函數原型為 int kill(pid_t pid, int signo);當第一個參數 pid>0 時，表示( A )
A 發送信號給進程 ID 為 pid 的進程;
24.共享主存基本操作( A )將共享主存區映射到進程虛擬地址空間。
A shmat()
25.修改消息隊列狀態信息的命令是(B)
B msgctl()
26.使用 gdb 調試程序時，next 和 step 命令的作用?( ) 統調用的函數原型 next:單步運行，不進入函數內部;
setp:單步運行，進入函數內部
27.Linux 系統的設備文件分為三類?( )
字符設備文件、塊設備文件和網絡設備文件
28.標準 I/O 提供了三種類型的緩沖，分別是?( )
全緩沖，行緩沖，不帶緩沖
29. 一個完整的信號生命周期包含 4 個重要的事件，這 4 個重要事件分別是?( )
信號誕生 信號在進程中注冊 信號在進程中注銷 信號處理函數執行完畢?30.互斥鎖只有兩種狀態，即?( )
開鎖和上鎖
31.在標準 IO 庫中，rewind 函數作用?( )
將文件流指針指向文件起始位置
32.c 語言中沒有明確給定初值的全局變量和靜態變量存放在哪兒?( )
未初始化數據區
33.函數 geteuid()用于得到進程的?( )
用戶有效 UID
34.一個進程是 ( )
C、PCB 結構與程序和數據的組合。
35.一個進程調用 wait 或 waitpid 函數，可能產生 3 中情況，下列不屬于這 3 種 情況的是 ( )。
D、如果該進程沒有子進程，立即返回，返回值為 0。 36.返回調用進程的進程標識號的系統函數是 ( )。
A、 getpid
37.程序和進程是兩個不同的概念，以下不能描述這個觀點的是 ( )。 B、同一個程序運行 10 次，產生的是同一個進程
38.fork 函數在父進程中的返回值是 ( )。
A、創建的子進程的進程標識號
39.在 Linux 中，下列不屬于正常結束進程的方法是 ( )。
D、調用 abort 函數。
40.以下程序的輸出結果是( )
int main(int argc, char *argv[])
{
printf("===================start of file\n"); pid_t pid = fork();
if (pid == -1) {
perror("fork error");
exit(1);
} else if (pid == 0) {
printf("---child,my pid is %d,my parent pid is %d\n",getpid(),getppid()); } else if (pid > 0) {
printf("---parent my child is %d,my pid is %d,myparent pid is %d\n", pid,getpid(),getppid());
sleep(1); }
printf("===================end of file\n");
return 0; }
B、===================start of file
---parent my child is 4759,my pid is 4758,myparent pid is 3700 ---child,my pid is 4759,my parent pid is 4758 ===================end of file ===================end of file 41.以下程序輸出結果是( )
int var = 100;
int main(void)
{
pid_t pid;
pid = fork();
if (pid == -1) {
perror("fork error");
exit(1);
} else if (pid > 0) {
var = 288;
printf("parent, var = %d\n", var);
sleep(1);
} else if (pid == 0) {
printf("child, var = %d\n", var); }
printf("------------finish---------------\n");
return 0; }
C、parent, var = 288
child, var = 100 ------------finish--------------- ------------finish--------------- 42.以下程序輸出結果是( )
int var = 100; int main(void) {
int *p;
pid_t pid;
int fd;
fd = open("temp", O_RDWR|O_CREAT|O_TRUNC, 0644); if(fd < 0){
perror("open error");
exit(1); }
ftruncate(fd, 4);
p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); if(p == MAP_FAILED){
perror("mmap error");
exit(1); }
close(fd); pid = fork(); if(pid == 0){
*p = 7000;
var = 1000;
printf("child, *p = %d, var = %d\n", *p, var);
} else { sleep(1);
printf("parent, *p = %d, var = %d\n", *p, var); wait(NULL);
int ret = munmap(p, 4);
if (ret == -1) {
perror("munmap error");
exit(1); }
}
return 0; }
A、child, *p = 7000, var = 1000
parent, *p = 0, var = 100
43.哪種進程之間的通信，數據不可以重復讀( )
B、fifo C、管道
44.下述是 Linux 下多線程編程常用的 pthread 庫提供的函數名和意義，說法不正確的是?( ) D、pthread_exit 殺死一個線程
45.對線程函數來說，說法正確的是( ):
A、pthread_create 中參數 arg 是傳遞給 start_routine 函數的參數 46.對互斥鎖及條件變量說法不正確的是( ):
D、在使用條件變量時，互斥鎖會失去作用，所以是否有互斥鎖關系不重要 47.以下說明正確的是( ): B、線程是一個獨立的指令流，是在進程中被創建的，隨進程的關閉而關閉
48.線程 A SendMessage 給線程 B，線程 B 處理該消息時又 SendMessage 給線程 A，會出現 ( ):
B、繼承執行
48.linux 文件系統通常由四部分組成:引導塊，超級塊，索引節點和( )。
B、數據塊 49.任何進程在運行時默認打開的三個流對象，都有相應的文件描述符，標準文件描述符定 義標準輸入設備的值為( )。
A、0
50.系統調用的函數原型 int open(const char *pathname, int flags)，flag 值中( )表示以讀寫的 方式打開文件。
C、O_RDWR
51 系統調用的函數原型 int open(const char *pathname, int flags)，flag 值中( )表示若文件 存在且為只讀或只寫成功打開，則將長度截為 0。
B、O_TRUNC
52.int main()
{
int fd,length;
fd=open("lseek.txt",O_RDWR);
length=lseek(fd,0,SEEK_END);
printf("the length os lseek is %d\n",length);
close(fd);
return 0;
}
此行代碼 length=lseek(fd,0,SEEK_END);中的 length 的值表示( )。
A、文件 lseek.txt 的大小
53.使用下列函數調用 int fcntl(int fd, int cmd);來實現文件描述符的復制，cmd 參數應使用哪 一個?
A、F_DUPFD 54.閱讀程序填空:如果想要獲取文件的大小，空白處應該填寫以下哪個答案。
int main(int argc, char *argv[])
{
struct stat statBuf;
if(stat(argv[1],&statBuf)<0)
{
perror("stat");
}
else
{
printf("the size of file is %ld", );
}
return 0;
}
A、 statBuf.st_size
55.在創建文件和目錄時候，有默認權限。如果 umask 值為 0022，則文件的默認權限為( ) B、0644
56.int main (void)
{
int fd; if((fd=open("tempfile",O_WRONLY|O_CREAT|O_TRUNC,0700))< 0) {
perror("open");
exit(1); }
if((link("tempfile","hardlink"))==-1) {
perror("open");
exit(1); }
struct stat statBuf;
fstat(fd, &statBuf);
printf("link num:%ld\n", statBuf.st_nlink); sleep(3);
if(unlink("tempfile") < 0)
{
perror("unlink");
exit(1); }
fstat(fd, &statBuf);
printf("unlink ,num:%ld\n", statBuf.st_nlink); return 0;
}
執行程序，代碼輸出結果為( )。 A.link num:2 57.獲取目錄的系統調用函數為( ) 。 B、getcwd()
選擇填空二 Linux 選擇填空
Jdb:b:設置斷點;r:執行程序;c:執行下面的程序
Vim:nyy:賦值 n 行;ndd:刪除 n 行;p 或 P:粘貼在光標所在行的下一行或者上一 行。
束時由 OS 回收。
控制信息、文件基本屬性等是 Inode 節點，為文件系統索引。存放數據的為數據塊。超 級塊中含有文件系統的基本信息，如塊大小、指向空間 inode 和數據塊的指針等相關信 息。
硬鏈接創建函數:link
刪除硬鏈接函數:unlink
軟連接創建函數:symlink
讀取軟連接中的內容所用的函數:readlink(文件名，讀取到的空間，讀取的大小)。
用于標識該打開文件，該值即文件描述符，為一個大于等于 0 的整數。
mkdir 函數:第一個參數時欲創建的目錄文件路徑，第二個參數時創建目錄的權限。
該子進程的內核進程資源。參數用來接受子進程退出狀態。返回值為子進程的 PID。 waitpid 函數，用來等待指定子進程結束。返回值為子進程的 PID。 第一個參數，大于 0 時，表示等待進程 PID 為該 PID 值的進程結束;
等于 0 時，表示等待與當前進程的進程組 PGID 一致的進程結束;
等于-1 時，與 wait 函數相同;
小于-1 時，表示等待進程組 PGID 是此值的絕對值的進程結束。 第二個參數用來接受等待進程的結束狀態。第三個參數一般設置為。
被取消線程運行:pthread_cancle()
互斥鎖的初始化:pthread_mutex_init() 條件變量的初始化:pthread_cond_init() 讀寫鎖的初始化:pthread_rwlock_init()
解鎖函數是 pthread_mutex_unlock()。
監聽網絡函數:listen() 發起連接函數:connect() 接受連接函數:accept()
讀寫 scoket 對象:read()/write()
TCP 發送和接受數據:send()/recv() 關閉 scoket 對象:close()
簡答題
http://172.31.36.15:9082/login?redirect=%2F
1.簡述一下系統調用和庫函數 舉例說明 庫函數:由系統提供,用戶無須定義,也不必在程序中作類型說明,只需在程序前包含有該函數 原型的頭文件即可在程序中直接調用 如使用 printf return 系統調用:操作系統的一部分;用戶應用程序訪問并使用內核所提供的各種服務的途徑即是系 統調用。如 exit
2.open 系統調用的打開標志 只讀:O_RDONLY 只寫:O_WRONLY
讀寫:O_RDWR 寫入時添加至文件末尾:O_APPEND 不存在時創建:O_CREAT 截斷文件為零長度:O_TRUNC
3. vfs 虛擬文件系統
虛擬文件系統(VirtualFileSystem, 簡稱 VFS)， 是 Linux 內核中的一個軟件層，用于給用 戶空間的程序提供文件系統接口;同時，它也提供了內核中的一個 抽象功能，允許不同的 文件系統共存。系統中所有的文件系統不但依賴 VFS 共存，而且也依靠 VFS 協同工作。
4. VFS 是什么
VFS 的作用就是采用標準的 Unix 系統調用讀寫位于不同物理介質上的不同文件系統,即 為 各類文件系統提供了一個統一的操作界面和應用編程接口。VFS 是一個可以讓 open()、read()、 write()等系統調用不用關心底層的存儲介質和文件系統類型就可以工作的粘合層。
5. linux 文件類型 普通文件、目錄文件、管道文件、字符設備文件、軟鏈接文件、塊文件、套接字文件
6. 什么是進程，進程資源由哪兩個組成 進程是計算機中程序的一次數據集合運算的活動，是系統進行調度和分配的基本單元，是操 作系統的基礎
進程資源由內核空間進程資源 用戶空間進程資源
7. 進程結構 一個正在運行著的進程在內存空間中申請的代碼區、初始化數據區、未初始化數據區、堆區、 棧區 5 個部分。
8. 程序與進程的區別 動態和靜態的區別:進程是程序及其數據在計算機上的一次運行活動，是一個動態的概念， 而程序是一組有序的指令集和，是一種靜態的概念 生命周期的區別:進程是程序的一次執行過程，他是動態創建和消亡的，程序是一組代碼的 集合，他是永久存在的
組成的區別:進程由程序 數據和 PCB 三部分組成，程序是一組有序的集合指令
9.fork 返回值的意義
如果執行成功，在父進程中將返回子進程的 PID，類型為 pid_t，子進程將返回 0，以區別父 子進程。
如果執行失敗，則在父進程中返回-1，錯誤原因存儲在 errno 中。
10.return 和 exit 的區別:
return 是語言級別的，它表示了調用堆棧的返回;而 exit 是系統調用級別的，它表示一個進 程的結束。
在 main 函數里，return(0)和 exit(0)是一樣的，子函數用 return 返回，而子進程用 exit 退出， 調用 exit 時要調用一段終止處理程序，然后關閉所有 I/O 流
11. 什么是孤兒進程 誰負責回收孤兒進程 孤兒進程就是其在正常運行時，父進程已經結束，導致其內核資源無法被父進程回收，孤兒 進程在父進程結束時將會把父進程設置為 init 進程，init 會對孤兒進程的資源進行回收處理
12.僵尸進程是什么，誰消滅 僵尸進程:進程已經退出，但它的父親進程還沒有回收內核資源的進程，即該進程在內核空 間的 PCB 沒有釋放。利用 kill 函數殺死父進程，僵尸進程會變成孤兒進程被 init 進程收養。
13. fork 和 vfork 的區別與聯系
區別:
fork()用于創建一個新進程。由 fork()創建的子進程是父進程的副本。即子進程獲取 父 進 程 數據空間，堆和 棧的副本。父子進程之間不共享這些存儲空間的部分。而 vfork()創建的進 程并不將父進程的地址空間完全復制到子進程中，因為子進程會立即調用 exec (或 exit) 于是也就不會存放該地址空間。相反，在子進程調用 exec 或 exit 之前，它在父 進 程 的 空間進行。
vfork()與 fork()另一個區別就是:vfork 保證子進程先運行，在它調用 exec 或 exit 之 后 父進程才可能被調度運行。
相同:
兩者被調用一次，但是返回兩次。兩次返回的唯一區別是子進程的返回值是 0，而 父 進 程 的返回值則是新子進程的進程 ID。
14.父進程調用 wait 能出現的三種情況
當子進程都在執行時，wait 會使父進程進入阻塞狀態 當恰好有子進程結束時，wait 會回收子進程資源并且獲得子進程結束狀態 當無子進程時 wait 會立刻返回-1 并且顯示報錯信息
15.簡述可靠信號和不可靠信號的處理過程: 如果進程在屏蔽某個信號的時間內，其他進程多次向其發送同一個信號，不可靠信號只有一 次未決記錄，當進程解除屏蔽后，該信號只會被捕捉一次;而可靠信號操作系統會記錄所有 的發送，當進程解除屏蔽后，操作系統會捕捉對等次數。
16.簡單介紹一下信號的定義及其分類。
信號是表示消息的物理量，是運載消息的工具 信號是軟件中斷，是在軟件層次上對中斷機制的一種模擬，在原理上，一個進程收到一個信 號與處理器收到一個中斷請求可以說是一樣的 分類:確定信號和隨機信號;連續信號和離散信;周期信號和非周期信號;能量信號與功率 信號;因果信號與反因果信號;實信號與復信號
17.進程間通信方式: 信號，匿名管道，命名管道，信號量，共享內存，消息隊列，套接字，Socket
18. 請解釋一下有名管道和匿名管道的區別?
匿名管道是由 pipe 函數創建 并打開的
命名管道是由 mkfifo 函數創建 的 ，打開用 open 命名管道和匿名管道唯一的區別就是在創建的打開，一旦這些工作完成后，它們有相同的意 義
19.簡單介紹一下匿名管道及其特點
匿名管道是半雙工的，只有一個寫端和一個讀端 匿名管道不是普通的文件，不是在磁盤上，而是在內存中的，所以它的生命周期隨進程的結 束而結束
匿名管道是基于字節流來通信的
其本身有同步互斥的效果
匿名管道只能使用于有血緣關系的進程之間的通信
20.Please describe the difference of signal() and sigaction() in brief(描述一下 signal 和 sigaction 的區別與聯系英文題)
不同點:signal 只能調用信號處理函數，但是無妨向其輸入附帶的數據
sigaction 可以向信號處理函數傳遞信息，并且可以設置信號掩碼，返回設置之前的 sigaction 相同點:都可以為信號設置信號處理函數
共用了同一個內核函數 do_sigaction
21.信號處理方式 忽略此信號。 自定義捕捉信號函數。 執行系統默認操作。
22. 信號產生的方式 當用戶按某些鍵時產生信號。 硬件異常產生信號。 終止進程信號。 軟件異常產生信號
23.信號的生命周期 在目的進程中安裝信號;進程產生信號;信號在目的進程中被注冊(目的進程收到信號); 信號在進程中被注銷(在執行相應處理函數之前);信號生命終止(執行完響應處理函數后 再恢復到被中斷的位置繼續執行)。
24.簡述什么是線程及特點 線程就是系統運算執行的最小單位，其所占資源較少 線程是進程的一個執行序列 線程可以看作是輕量化的進程，線程之間的切換代價小
25.pthread_kill 函數和 pthread_cancle 函數的區別:(兩個都是終止進程的)
pthread_kill 函數的功能是向指定線程發送信號，信號為 0 時用于檢查此線程 ID 的線程 是 否存活。
pthread_cancel 函數的功能是給線程發送取消信號，使線程從取消點退出。
26. pthread_exit()和 pthread_cancel()的區別 pthread_exit()是結束本線程 pthread_cancel()是結束其他線程
27. 簡述互斥鎖與讀寫鎖的區別與聯系。
區別:讀寫鎖區分讀者和寫者，而互斥鎖不區分 互斥鎖同一時間只允許一個線程訪問該對象，無論讀寫;讀寫鎖同一時間內只允許一個寫者， 但是允許多個讀者同時讀對象。
聯系:讀寫鎖在獲取寫鎖的時候機制類似于互斥鎖。
28.條件變量中 pthread_cond_wait 實現的步驟
解鎖 判斷條件是否成立 如果成立則上鎖執行，不成立將進入阻塞狀態
29. 線程與進程的區別
進程是資源分配的最小單位，線程是程序執行的最小單位。 進程有自己的獨立地址空間，每啟動一個進程，系統就會為它分配地址空間，建立數 據 表來維護代碼段、堆棧段和數據段。而線程是共享進程中的數據的，使用相同的地址 空 間，因此 CPU 切換一個線程的花費遠比進程要小很多，同時創建一個線程的開銷也 比 進程要小很多。 線程之間的通信更方便，同一進程下的線程共享全局變量、靜態變量等數據，而進程 之 間的通信需要以通信的方式進行。 多進程程序更健壯，多線程程序只要有一個線程死掉，整個進程也死掉了，而一個進 程 死掉并不會對另外一個進程造成影響，因為進程有自己獨立的地址空間。
30. tcp 和 udp 的區別
TCP 需要連接，UDP 是無連接的，發送數據之前不需要建立連接 TCP 提供可靠的服務，通過 TCP 連接傳送的數據，無差錯，不丟失 TCP 邏輯通信信道是全雙工的可靠信道，UDP 則是不可靠信道
31. TCP 的三次握手
第一次握手
客戶主動(active open)去 connect 服務器，并且發送 SYN 假設序列號為 J, 服務器是被動打開(passive open)
第二次握手
服務器在收到 SYN 后，它會發送一個 SYN 以及一個 ACK(應答)給客戶， ACK 的序列號是 J+1 表示是給 SYN J 的應答，新發送的 SYN K 序列號是 K 第三次握手
客戶在收到新 SYN K, ACK J+1 后，也回應 ACK K+1 以表示收到了， 然后兩邊就可以開始數據發送數據了
32. osi 七層模型
應用層 表示層 會話層 傳輸層 網絡層 數據鏈路層 物理層
33.使用 gdb 調試程序時，next 和 step 命令的作用? next:單步運行，不進入函數內部; setp:單步運行，進入函數內部
34.Linux 系統的設備文件分為三類?
字符設備文件、塊設備文件和網絡設備文件
35.標準 I/O 提供了三種類型的緩沖，分別是? 全緩沖，行緩沖，不帶緩沖
36. 一個完整的信號生命周期包含 4 個重要的事件，這 4 個重要事件分別是? 信號誕生 信號在進程中注冊 信號在進程中注銷 信號處理函數執行完畢
37.互斥鎖只有兩種狀態，即? 開鎖和上鎖
38.在標準 IO 庫中，rewind 函數作用? 將文件流指針指向文件起始位置
39.c 語言中沒有明確給定初值的全局變量和靜態變量存放在哪兒? 未初始化數據區
40.函數 geteuid()用于得到進程的? 用戶有效 UID
編程題
http://172.31.36.15:9082/login?redirect=%2F
1.創建文件 file1，寫入字符串“abcdefghijklmn”;
創建文件 file2，寫入字符串“ABCDEFGHIJKLMN”;
讀取 file1 中的內容，寫入 file2，使 file2 中的字符串內容為“abcdefghijklmn ABCDEFGHIJKLMN” #include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
int main()
{
int fd1,fd2;
char str[14];
fd1 = open("file1",O_RDWR|O_CREAT,S_IRWXU); if(fd1 < 0)
perror("open"); write(fd1,"abcdefghijklmn",14); lseek(fd1,0,SEEK_SET);
fd2 = open("file2",O_RDWR|O_CREAT,S_IRWXU); if(fd2 < 0)
perror("open");
lseek(fd2,14,SEEK_END); write(fd2,"ABCDEFGHIJKLMN",14); read(fd1,str,14); lseek(fd2,0,SEEK_SET); write(fd2,str,14);
close(fd1); close(fd2); system("cat file2");
printf("\n"); return 0;
}
2.創建新文件，該文件具有用戶讀寫權限。
采用 dup/dup2/fcntl 復制一個新的文件描述符，通過新文件描述符向文件寫入“class_name” 字符串;
通過原有的文件描述符讀取文件中的內容，并且打印顯示
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
int fd,fd1;
char *str = "class_name";
fd = open("file",O_CREAT|O_RDWR); if(fd < 0)
perror("open"); fd1 = dup(fd); if(fd1 < 0)
perror("dup"); write(fd1,str,strlen(str)); lseek(fd,0,SEEK_SET);
char buf[12]; read(fd,buf,12);
printf("The buf is:%s\n",buf); close(fd);
close(fd1);
return 0; }
3.遞歸遍歷/home 目錄，打印出所有文件和子目錄名稱及節點號。 判斷文件類型，如果是子目錄，繼續進行遞歸遍歷，直到遍歷完所有子目錄為止。
#include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <dirent.h> #include <sys/stat.h> #include <sys/types.h> void show(char *path)
{
DIR *dir;
char str[128];
struct dirent *dirp; struct stat statbuf; dir = opendir(path); if(dir)
{
while((dirp = readdir(dir)) != NULL) {
sprintf(str,"%s/%s",path,dirp->d_name); if(lstat(str,&statbuf) < 0)
perror("lstat");
if(dirp->d_name[0] == '.') continue;
if(S_ISDIR(statbuf.st_mode)) {
show(str);
printf("The dirent's name is: %s\n",dirp->d_name); printf("The dirent's inode is: %d\n",dirp->d_ino);
} else {
printf("The file's inode is: %d\n",dirp->d_ino); }
} }
else
perror("opendir");
closedir(dir); }
int main() {
printf("The file's name is: %s\n",dirp->d_name);
show("/home");
return 0; }
4.打印字符串“hello world!”
在打印字符串“hello world!”前調用三次 fork，分析打印結果。
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> int main()
{
fork();
fork();
fork();
printf("hello world!!!\n"); return 0
}
5.創建子進程
在子進程中打開文件 file1，寫入自己的“班級_姓名_學號”，
父進程讀取 file1 中的內容，并且打印顯示。 在父進程中獲取已經結束的子進程的狀態信息，打印該信息，并且打印結束的子進程的進程 號。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
int main()
{
int fd,pid;
fd = open("file",O_CREAT|O_RDWR,S_IRWXU); if(fd< 0)
perror("open"); pid = fork(); if(pid == 0)
{
printf("This is the child!\n");
char str[128] = "移動二班_段振威_1915925158"; if(write(fd,str,128) < 0)
perror("write"); exit(5);
} else {
printf("This is the father!\n");
char buf[128];
int n,status; if(read(fd,buf,128) < 0)
perror("read");
printf("The buf is: %s\n",buf); if(wait(&status) < 0)
perror("perror"); if(WIFEXITED(status))
n = WEXITSTATUS(status); else
printf("wait error!\n");
printf("The child's pid is: %d\n",pid); printf("The child exit status is: %d\n",n);
}
return 0; }
6.在父進程中定義變量 n，在子進程中對變量 n 進行++操作;并且打印變量 n 的值，打印子 進程 pid;
在父進程中打印變量 n 的值，并且打印父進程 pid。
要求分別用 fork 和 vfork 創建子進程。
//------fork
#include <stdio.h> #include <stdlib.h> #include <sys/wait.h> #include <unistd.h> int main()
{
int n = 1; if(fork() == 0) {
printf("This is child,the pid is%d\n",getpid());
printf("The n is: %d\n",++n); }
else {
printf("The n is: %d\n",n); }
printf("This is father,the pid is%d\n",getpid());
return 0; }
//-----vfork #include <stdio.h> #include <stdlib.h> #include <unistd.h> int main()
{
int n = 1; pid_t pid; pid = vfork(); if(pid < 0)
perror("vfork"); else if(pid == 0) {
printf("This is child,the child's pid is: %d\n",getpid()); printf("The n is: %d\n",++n);
exit(0);
} else {
printf("The n is: %d\n",n); }
return 0; }
7.利用匿名管道實現父子進程間通信，要求
父進程發送字符串“hello child”給子進程; 子進程收到父進程發送的數據后，給父進程回復“hello farther”; 父子進程通信完畢，父進程依次打印子進程的退出狀態以及子進程的 pid。 #include <stdio.h>
#include <stdlib.h> #include <unistd.h> #include <sys/wait.h> int main()
{
int fd1[2],fd2[2];
pipe(fd1); pipe(fd2); int pid;
pid = fork(); if(pid < 0)
perror("fork");
printf("This is father,the father's pid is: %d\n",getpid());
else if(pid == 0) {
close(fd1[0]);
close(fd2[1]);
char str[12];
printf("This is the child!\n");
if(read(fd2[0],str,12) > 0) {
printf("Received the news: %s\n",str); if(write(fd1[1],"hello father",12) < 0)
perror("write"); }
else
perror("read");
exit(5); }
else {
int status;
printf("This is the father!\n");
close(fd1[1]);
close(fd2[0]);
char buf[24] = "hello child"; if(write(fd2[1],buf,12) < 0)
perror("write"); else
{
printf("Send news successful!\n");
}
wait(&status); if(WIFEXITED(status)) {
printf("The child's pid is: %d\n",pid);
printf("The child's exited status is: %d\n",WEXITSTATUS(status)); }
}
return 0; }
8. 利用匿名管道實現兄弟進程間通信，要求
兄進程發送字符串“This is elder brother ，pid is (兄進程進程號)”給第進程;
第進程收到兄進程發送的數據后，給兄進程回復“This is younger brother ，pid is(第進程進 程號)”;
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> #include <fcntl.h> #include <sys/stat.h> int main()
{
int fd1[2],fd2[2];
pipe(fd1); pipe(fd2); int pid;
pid = fork(); if(pid == 0) {
printf("This is the elder brother!\n");
printf("The elder's father's pid is: %d\n",getppid()); close(fd1[1]);
close(fd2[0]);
char str1[64],str2[64];
sprintf(str1,"This is the elder brother,pid is %d",getpid()); if(write(fd2[1],str1,64) < 0)
perror("write"); if(read(fd1[0],str2,64) < 0)
perror("read"); else
printf("The news from younger is: %s\n",str2); }
else {
if(fork() == 0) {
printf("This is the younger brother!\n");
printf("The younger's father's pid is: %d\n",getppid()); close(fd1[0]);
close(fd2[1]);
char buf1[64],buf2[64];
if(read(fd2[0],buf1,64) > 0)
{
printf("The news form elder is: %s\n",buf1); sprintf(buf2,"This is the younger brother,pid is %d",getpid());
if(write(fd1[1],buf2,64) < 0)
perror("write");
} else
perror("read"); }
} }
9. 利用有名管道文件實現進程間通信，要求 寫進程向有名管道文件寫入 10 次“hello world”; 讀進程讀取有名管道文件中的內容，并依次打印 #include <stdio.h>
#include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <sys/stat.h> int main()
{
int pid,fd;
if(mkfifo("fifotest",0666) < 0) perror("mkfifo");
pid = fork(); if(pid < 0)
perror("fork"); else if(pid == 0) {
printf("This is the write process!\n"); int fd = open("fifotest",0666);
for(int i = 0; i < 10;i++) {
if(write(fd,"hello world",12) < 0) perror("write");
sleep(1); }
close(fd); }
else {
char str[128];
printf("This is the read process!\n"); int fd1 = open("fifotest",0666); for(int i = 0;i < 10;i++)
{
if(read(fd1,str,128) < 0) perror("read");
else printf("%s\n",str);
}
system("rm -f fifotest"); }
} https://blog.csdn.net/Wangguang_/article/details/90413286?utm_source=app
總結
以上是生活随笔為你收集整理的linux选择填空题的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 远程连接GitHub仓库
- 下一篇： linux音频函数接口,Linux音频驱