linux進程編程
給你發個常式，一起復習一下：
#include <sys/types.h>
#include <sys/msg.h>
#include <unistd.h>
void msg_stat(int,struct msqid_ds );
main()
{
int gflags,sflags,rflags;
key_t key;
int msgid;
int reval;
struct msgsbuf{
int mtype;
char mtext[1];
}msg_sbuf;
struct msgmbuf
{
int mtype;
char mtext[10];
}msg_rbuf;
struct msqid_ds msg_ginfo,msg_sinfo;
char* msgpath="/unix/msgqueue";
key=ftok(msgpath,'a');
gflags=IPC_CREAT|IPC_EXCL;
msgid=msgget(key,gflags|00666);
if(msgid==-1)
{
printf("msg create error\n");
return;
}
//創建一個消息隊列後，輸出消息隊列預設屬性
msg_stat(msgid,msg_ginfo);
sflags=IPC_NOWAIT;
msg_sbuf.mtype=10;
msg_sbuf.mtext[0]='a';
reval=msgsnd(msgid,&msg_sbuf,sizeof(msg_sbuf.mtext),sflags);
if(reval==-1)
{
printf("message send error\n");
}
//發送一個消息後，輸出消息隊列屬性
msg_stat(msgid,msg_ginfo);
rflags=IPC_NOWAIT|MSG_NOERROR;
reval=msgrcv(msgid,&msg_rbuf,4,10,rflags);
if(reval==-1)
printf("read msg error\n");
else
printf("read from msg queue %d bytes\n",reval);
//從消息隊列中讀出消息後，輸出消息隊列屬性
msg_stat(msgid,msg_ginfo);
msg_sinfo.msg_perm.uid=8;//just a try
msg_sinfo.msg_perm.gid=8;//
msg_sinfo.msg_qbytes=16388;
//此處驗證超級用戶可以更改消息隊列的預設msg_qbytes
//注意這里設置的值大於預設值
reval=msgctl(msgid,IPC_SET,&msg_sinfo);
if(reval==-1)
{
printf("msg set info error\n");
return;
}
msg_stat(msgid,msg_ginfo);
//驗證設置消息隊列屬性
reval=msgctl(msgid,IPC_RMID,NULL);//刪除消息隊列
if(reval==-1)
{
printf("unlink msg queue error\n");
return;
}
}
void msg_stat(int msgid,struct msqid_ds msg_info)
{
int reval;
sleep(1);//只是為了後面輸出時間的方便
reval=msgctl(msgid,IPC_STAT,&msg_info);
if(reval==-1)
{
printf("get msg info error\n");
return;
}
printf("\n");
printf("current number of bytes on queue is %d\n",msg_info.msg_cbytes);
printf("number of messages in queue is %d\n",msg_info.msg_qnum);
printf("max number of bytes on queue is %d\n",msg_info.msg_qbytes);
//每個消息隊列的容量（位元組數）都有限制MSGMNB，值的大小因系統而異。在創建新的消息隊列時，//msg_qbytes的預設值就是MSGMNB
printf("pid of last msgsnd is %d\n",msg_info.msg_lspid);
printf("pid of last msgrcv is %d\n",msg_info.msg_lrpid);
printf("last msgsnd time is %s", ctime(&(msg_info.msg_stime)));
printf("last msgrcv time is %s", ctime(&(msg_info.msg_rtime)));
printf("last change time is %s", ctime(&(msg_info.msg_ctime)));
printf("msg uid is %d\n",msg_info.msg_perm.uid);
printf("msg gid is %d\n",msg_info.msg_perm.gid);
}
② 在Linux編程中，父進程為什麼要等待並回收子進程的退出狀態不這樣做會有什麼後果
分幾種情況：
父進程永不退出：這種情況下若子進程退出，而父進程沒有收集子進程的退出狀態，則此子進程會變為僵屍進程，一直佔用少量資源，有危害；
父進程比子進程先退出：這種情況下父進程退出時，仍在運行的子進程會變為孤兒進程，孤兒進程會被託管給init進程，孤兒進程結束時由init進程負責回收；
父進程比子進程晚退出：子進程先退出時會變為僵屍進程，佔用少量資源；待到父進程再退出時，子進程由僵屍進程變為孤兒進程，init進程會回收這些已僵死的孤兒進程，則這些已經僵死的孤兒進程就能瞑目而去了；
③ LINUX下系統編程，進程通訊
memcpy比較好，strcpy是碰到了'\0'才會停下來。在你的結構體裡面就沒有出現過這個字元串結尾的標志，拷貝內存會出錯的，一致拷貝，直到超出了共享內存的邊界，然後就會出錯。
沒怎麼改動
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<sys/wait.h>
#include<stdlib.h>
#include<signal.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<string.h>
#define BUF_SIZE 100
#define KEY 98
struct task_str{ //進程的數據結構
int priority; //優先順序
int wto; //進程唯一標志
};
struct task_str task;
void init()
{
int shmid;
struct task_str *shmptr;
shmid=shmget(KEY,BUF_SIZE,IPC_CREAT|0666);
if(shmid==-1)
{
printf("Shared Memory Created error...\n");
exit(0);
}
shmptr=shmat(shmid,NULL,0);
if(shmptr==(void*)-1)
{
printf("shmat error \n");
exit(1);
}
task.priority=90;
task.wto=30; //strcpy(shmptr,task);
//shmptr=&task;
memcpy(shmptr,&task,sizeof(task));
printf("p=%d,wto=%d\n",(struct task_str*)shmptr->priority,(struct task_str*)shmptr->wto);
int a=0;
for(a=0;a<5;a++)
{
printf("task is diong ...\n");
sleep(1);
}
// execl("/bin/ls","ls",NULL);
}
int main()
{
int i; int a;
pid_t pid=0;
pid=fork();
if (pid == 0) /* 子進程執行此命令 */
{
init();
}
else if(pid > 0)
{
wait(&a);
int shmid;
//struct task_str *shmptr;這里不用這樣，只需要一般的指針就可以了。
void *shmptr=NULL;
shmid=shmget(KEY,BUF_SIZE,IPC_CREAT|0666);
if(shmid==-1)
{
printf("Shared Memory Created error...\n");
exit(0);
}
shmptr=shmat(shmid,NULL,0);
if(shmptr==(void*)-1)
{
printf("shmat error \n");
exit(1);
}
struct task_str * p;
//strcpy(p,shmptr);
//p=&task;
p=(struct task_str*)shmptr; //指向共享內存即可
printf("//////////////////%d\n",p->priority);
printf("******************%d\n",p->wto); //這里不應該用.，而是->，因為是指針。
return 0;
}
}
④ Linux 編程
第一個參數表示進程名
第二個參數相當於argv[0]，這里是sh，其實由於PATH環境變數的原因所以你可以這么使用
而事實上這句應該是/bin/sh這樣的絕對路徑
第三個四三參數相當於argv[1] argv[2]。。。。。
即由第二個參數開始相當於c語言中main函數的char **argv
然後這個命令行參數由NULL來結束
這個函數會在使用的地方將另一個外部程序拷貝到執行這個函數的地址處
並從該外部程序的頭開始執行該外部程序
這就是說在調用該函數處後面的原代碼被載入進來的外部程序代碼覆蓋掉
所以在某個程序中調用外部另一個程序而又保持調用程序不會被覆蓋的方法就是
調用程序創建一個進程，然後調用該函數將外部程序的代碼覆蓋掉新進程
這其實就是一個創建新進程調用外部程序的
像linux的bash其實都使用了這種方法對外部程序進行調用
⑤ 一個Linux多進程編程
1 引言
對於沒有接觸過Unix/Linux操作系統的人來說，fork是最難理解的概念之一：它執行一次卻返回兩個值。fork函數是Unix系統最傑出的成就之一，它是七十年代UNIX早期的開發者經過長期在理論和實踐上的艱苦探索後取得的成果，一方面，它使操作系統在進程管理上付出了最小的代價，另一方面，又為程序員提供了一個簡潔明了的多進程方法。與DOS和早期的Windows不同，Unix/Linux系統是真正實現多任務操作的系統，可以說，不使用多進程編程，就不能算是真正的Linux環境下編程。
多線程程序設計的概念早在六十年代就被提出，但直到八十年代中期，Unix系統中才引入多線程機制，如今，由於自身的許多優點，多線程編程已經得到了廣泛的應用。
下面，我們將介紹在Linux下編寫多進程和多線程程序的一些初步知識。
2 多進程編程
什麼是一個進程？進程這個概念是針對系統而不是針對用戶的，對用戶來說，他面對的概念是程序。當用戶敲入命令執行一個程序的時候，對系統而言，它將啟動一個進程。但和程序不同的是，在這個進程中，系統可能需要再啟動一個或多個進程來完成獨立的多個任務。多進程編程的主要內容包括進程式控制制和進程間通信，在了解這些之前，我們先要簡單知道進程的結構。
2.1 Linux下進程的結構
Linux下一個進程在內存里有三部分的數據，就是"代碼段"、"堆棧段"和"數據段"。其實學過匯編語言的人一定知道，一般的CPU都有上述三種段寄存器，以方便操作系統的運行。這三個部分也是構成一個完整的執行序列的必要的部分。
"代碼段"，顧名思義，就是存放了程序代碼的數據，假如機器中有數個進程運行相同的一個程序，那麼它們就可以使用相同的代碼段。"堆棧段"存放的就是子程序的返回地址、子程序的參數以及程序的局部變數。而數據段則存放程序的全局變數，常數以及動態數據分配的數據空間（比如用malloc之類的函數取得的空間）。這其中有許多細節問題，這里限於篇幅就不多介紹了。系統如果同時運行數個相同的程序，它們之間就不能使用同一個堆棧段和數據段。
2.2 Linux下的進程式控制制
在傳統的Unix環境下，有兩個基本的操作用於創建和修改進程：函數fork( )用來創建一個新的進程，該進程幾乎是當前進程的一個完全拷貝；函數族exec( )用來啟動另外的進程以取代當前運行的進程。Linux的進程式控制制和傳統的Unix進程式控制制基本一致，只在一些細節的地方有些區別，例如在Linux系統中調用vfork和fork完全相同，而在有些版本的Unix系統中，vfork調用有不同的功能。由於這些差別幾乎不影響我們大多數的編程，在這里我們不予考慮。
2.2.1 fork( )
fork在英文中是"分叉"的意思。為什麼取這個名字呢？因為一個進程在運行中，如果使用了fork，就產生了另一個進程，於是進程就"分叉"了，所以這個名字取得很形象。下面就看看如何具體使用fork，這段程序演示了使用fork的基本框架：
void main(){
int i;
if ( fork() == 0 ) {
/* 子進程程序 */
for ( i = 1; i <1000; i ++ ) printf("This is child process\n");
}
else {
/* 父進程程序*/
for ( i = 1; i <1000; i ++ ) printf("This is process process\n");
}
}
程序運行後，你就能看到屏幕上交替出現子進程與父進程各列印出的一千條信息了。如果程序還在運行中，你用ps命令就能看到系統中有兩個它在運行了。
那麼調用這個fork函數時發生了什麼呢？fork函數啟動一個新的進程，前面我們說過，這個進程幾乎是當前進程的一個拷貝：子進程和父進程使用相同的代碼段；子進程復制父進程的堆棧段和數據段。這樣，父進程的所有數據都可以留給子進程，但是，子進程一旦開始運行，雖然它繼承了父進程的一切數據，但實際上數據卻已經分開，相互之間不再有影響了，也就是說，它們之間不再共享任何數據了。它們再要交互信息時，只有通過進程間通信來實現，這將是我們下面的內容。既然它們如此相象，系統如何來區分它們呢？這是由函數的返回值來決定的。對於父進程，fork函數返回了子程序的進程號，而對於子程序，fork函數則返回零。在操作系統中，我們用ps函數就可以看到不同的進程號，對父進程而言，它的進程號是由比它更低層的系統調用賦予的，而對於子進程而言，它的進程號即是fork函數對父進程的返回值。在程序設計中，父進程和子進程都要調用函數fork（）下面的代碼，而我們就是利用fork（）函數對父子進程的不同返回值用if...else...語句來實現讓父子進程完成不同的功能，正如我們上面舉的例子一樣。我們看到，上面例子執行時兩條信息是交互無規則的列印出來的，這是父子進程獨立執行的結果，雖然我們的代碼似乎和串列的代碼沒有什麼區別。
讀者也許會問，如果一個大程序在運行中，它的數據段和堆棧都很大，一次fork就要復制一次，那麼fork的系統開銷不是很大嗎？其實UNIX自有其解決的辦法，大家知道，一般CPU都是以"頁"為單位來分配內存空間的，每一個頁都是實際物理內存的一個映像，象INTEL的CPU，其一頁在通常情況下是4086位元組大小，而無論是數據段還是堆棧段都是由許多"頁"構成的，fork函數復制這兩個段，只是"邏輯"上的，並非"物理"上的，也就是說，實際執行fork時，物理空間上兩個進程的數據段和堆棧段都還是共享著的，當有一個進程寫了某個數據時，這時兩個進程之間的數據才有了區別，系統就將有區別的"頁"從物理上也分開。系統在空間上的開銷就可以達到最小。
下面演示一個足以"搞死"Linux的小程序，其源代碼非常簡單：
void main()
{
for( ; ; ) fork();
}
這個程序什麼也不做，就是死循環地fork，其結果是程序不斷產生進程，而這些進程又不斷產生新的進程，很快，系統的進程就滿了，系統就被這么多不斷產生的進程"撐死了"。當然只要系統管理員預先給每個用戶設置可運行的最大進程數，這個惡意的程序就完成不了企圖了。
2.2.2 exec( )函數族
下面我們來看看一個進程如何來啟動另一個程序的執行。在Linux中要使用exec函數族。系統調用execve（）對當前進程進行替換，替換者為一個指定的程序，其參數包括文件名（filename）、參數列表（argv）以及環境變數（envp）。exec函數族當然不止一個，但它們大致相同，在Linux中，它們分別是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp為例，其它函數究竟與execlp有何區別，請通過manexec命令來了解它們的具體情況。
一個進程一旦調用exec類函數，它本身就"死亡"了，系統把代碼段替換成新的程序的代碼，廢棄原有的數據段和堆棧段，並為新程序分配新的數據段與堆棧段，唯一留下的，就是進程號，也就是說，對系統而言，還是同一個進程，不過已經是另一個程序了。（不過exec類函數中有的還允許繼承環境變數之類的信息。）
那麼如果我的程序想啟動另一程序的執行但自己仍想繼續運行的話，怎麼辦呢？那就是結合fork與exec的使用。下面一段代碼顯示如何啟動運行其它程序：
char command[256];
void main()
{
int rtn; /*子進程的返回數值*/
while(1) {
/* 從終端讀取要執行的命令 */
printf( ">" );
fgets( command, 256, stdin );
command[strlen(command)-1] = 0;
if ( fork() == 0 ) {
/* 子進程執行此命令 */
execlp( command, command );
/* 如果exec函數返回，表明沒有正常執行命令，列印錯誤信息*/
perror( command );
exit( errorno );
}
else {
/* 父進程， 等待子進程結束，並列印子進程的返回值 */
wait ( &rtn );
printf( " child process return %d\n",. rtn );
}
}
}
此程序從終端讀入命令並執行之，執行完成後，父進程繼續等待從終端讀入命令。熟悉DOS和WINDOWS系統調用的朋友一定知道DOS/WINDOWS也有exec類函數，其使用方法是類似的，但DOS/WINDOWS還有spawn類函數，因為DOS是單任務的系統，它只能將"父進程"駐留在機器內再執行"子進程"，這就是spawn類的函數。WIN32已經是多任務的系統了，但還保留了spawn類函數，WIN32中實現spawn函數的方法同前述UNIX中的方法差不多，開設子進程後父進程等待子進程結束後才繼續運行。UNIX在其一開始就是多任務的系統，所以從核心角度上講不需要spawn類函數。
在這一節里，我們還要講講system（）和popen（）函數。system（）函數先調用fork（），然後再調用exec（）來執行用戶的登錄shell，通過它來查找可執行文件的命令並分析參數，最後它么使用wait（）函數族之一來等待子進程的結束。函數popen（）和函數system（）相似，不同的是它調用pipe（）函數創建一個管道，通過它來完成程序的標准輸入和標准輸出。這兩個函數是為那些不太勤快的程序員設計的，在效率和安全方面都有相當的缺陷，在可能的情況下，應該盡量避免。
2.3 Linux下的進程間通信
詳細的講述進程間通信在這里絕對是不可能的事情，而且筆者很難有信心說自己對這一部分內容的認識達到了什麼樣的地步，所以在這一節的開頭首先向大家推薦著名作者Richard Stevens的著名作品：《Advanced Programming in the UNIX Environment》，它的中文譯本《UNIX環境高級編程》已有機械工業出版社出版，原文精彩，譯文同樣地道，如果你的確對在Linux下編程有濃厚的興趣，那麼趕緊將這本書擺到你的書桌上或計算機旁邊來。說這么多實在是難抑心中的景仰之情，言歸正傳，在這一節里，我們將介紹進程間通信最最初步和最最簡單的一些知識和概念。
首先，進程間通信至少可以通過傳送打開文件來實現，不同的進程通過一個或多個文件來傳遞信息，事實上，在很多應用系統里，都使用了這種方法。但一般說來，進程間通信（IPC：InterProcess Communication）不包括這種似乎比較低級的通信方法。Unix系統中實現進程間通信的方法很多，而且不幸的是，極少方法能在所有的Unix系統中進行移植（唯一一種是半雙工的管道，這也是最原始的一種通信方式）。而Linux作為一種新興的操作系統，幾乎支持所有的Unix下常用的進程間通信方法：管道、消息隊列、共享內存、信號量、套介面等等。下面我們將逐一介紹。
2.3.1 管道
管道是進程間通信中最古老的方式，它包括無名管道和有名管道兩種，前者用於父進程和子進程間的通信，後者用於運行於同一台機器上的任意兩個進程間的通信。
無名管道由pipe（）函數創建：
#include <unistd.h>
int pipe(int filedis[2])；
參數filedis返回兩個文件描述符：filedes[0]為讀而打開，filedes[1]為寫而打開。filedes[1]的輸出是filedes[0]的輸入。下面的例子示範了如何在父進程和子進程間實現通信。
#define INPUT 0
#define OUTPUT 1
void main() {
int file_descriptors[2];
/*定義子進程號 */
pid_t pid;
char buf[256];
int returned_count;
/*創建無名管道*/
pipe(file_descriptors);
/*創建子進程*/
if((pid = fork()) == -1) {
printf("Error in fork\n");
exit(1);
}
/*執行子進程*/
if(pid == 0) {
printf("in the spawned (child) process...\n");
/*子進程向父進程寫數據，關閉管道的讀端*/
close(file_descriptors[INPUT]);
write(file_descriptors[OUTPUT], "test data", strlen("test data"));
exit(0);
} else {
/*執行父進程*/
printf("in the spawning (parent) process...\n");
/*父進程從管道讀取子進程寫的數據，關閉管道的寫端*/
close(file_descriptors[OUTPUT]);
returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
printf("%d bytes of data received from spawned process: %s\n",
returned_count, buf);
}
}
在Linux系統下，有名管道可由兩種方式創建：命令行方式mknod系統調用和函數mkfifo。下面的兩種途徑都在當前目錄下生成了一個名為myfifo的有名管道：
方式一：mkfifo("myfifo","rw");
方式二：mknod myfifo p
生成了有名管道後，就可以使用一般的文件I/O函數如open、close、read、write等來對它進行操作。下面即是一個簡單的例子，假設我們已經創建了一個名為myfifo的有名管道。
/* 進程一：讀有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * in_file;
int count = 1;
char buf[80];
in_file = fopen("mypipe", "r");
if (in_file == NULL) {
printf("Error in fdopen.\n");
exit(1);
}
while ((count = fread(buf, 1, 80, in_file)) > 0)
printf("received from pipe: %s\n", buf);
fclose(in_file);
}
/* 進程二：寫有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * out_file;
int count = 1;
char buf[80];
out_file = fopen("mypipe", "w");
if (out_file == NULL) {
printf("Error opening pipe.");
exit(1);
}
sprintf(buf,"this is test data for the named pipe example\n");
fwrite(buf, 1, 80, out_file);
fclose(out_file);
}
2.3.2 消息隊列
消息隊列用於運行於同一台機器上的進程間通信，它和管道很相似，事實上，它是一種正逐漸被淘汰的通信方式，我們可以用流管道或者套介面的方式來取代它，所以，我們對此方式也不再解釋，也建議讀者忽略這種方式。
2.3.3 共享內存
共享內存是運行在同一台機器上的進程間通信最快的方式，因為數據不需要在不同的進程間復制。通常由一個進程創建一塊共享內存區，其餘進程對這塊內存區進行讀寫。得到共享內存有兩種方式：映射/dev/mem設備和內存映像文件。前一種方式不給系統帶來額外的開銷，但在現實中並不常用，因為它控制存取的將是實際的物理內存，在Linux系統下，這只有通過限制Linux系統存取的內存才可以做到，這當然不太實際。常用的方式是通過shmXXX函數族來實現利用共享內存進行存儲的。
首先要用的函數是shmget，它獲得一個共享存儲標識符。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, int size, int flag);
這個函數有點類似大家熟悉的malloc函數，系統按照請求分配size大小的內存用作共享內存。Linux系統內核中每個IPC結構都有的一個非負整數的標識符，這樣對一個消息隊列發送消息時只要引用標識符就可以了。這個標識符是內核由IPC結構的關鍵字得到的，這個關鍵字，就是上面第一個函數的key。數據類型key_t是在頭文件sys/types.h中定義的，它是一個長整形的數據。在我們後面的章節中，還會碰到這個關鍵字。
當共享內存創建後，其餘進程可以調用shmat（）將其連接到自身的地址空間中。
void *shmat(int shmid, void *addr, int flag);
shmid為shmget函數返回的共享存儲標識符，addr和flag參數決定了以什麼方式來確定連接的地址，函數的返回值即是該進程數據段所連接的實際地址，進程可以對此進程進行讀寫操作。
使用共享存儲來實現進程間通信的注意點是對數據存取的同步，必須確保當一個進程去讀取數據時，它所想要的數據已經寫好了。通常，信號量被要來實現對共享存儲數據存取的同步，另外，可以通過使用shmctl函數設置共享存儲內存的某些標志位如SHM_LOCK、SHM_UNLOCK等來實現。
⑥ 一個進程通信 的 linux程序編寫
學習步驟如下：
1、Linux 基礎
安裝Linux操作系統
Linux文件系統
Linux常用命令
Linux啟動過程詳解
熟悉Linux服務能夠獨立安裝Linux操作系統
能夠熟練使用Linux系統的基本命令
認識Linux系統的常用服務安裝Linux操作系統
Linux基本命令實踐
設置Linux環境變數
定製Linux的服務 Shell 編程基礎使用vi編輯文件
使用Emacs編輯文件
使用其他編輯器
2、Shell 編程基礎
Shell簡介
認識後台程序
Bash編程熟悉Linux系統下的編輯環境
熟悉Linux下的各種Shell
熟練進行shell編程熟悉vi基本操作
熟悉Emacs的基本操作
比較不同shell的區別
編寫一個測試伺服器是否連通的shell腳本程序
編寫一個查看進程是否存在的shell腳本程序
編寫一個帶有循環語句的shell腳本程序
3、Linux 下的 C 編程基礎
linux C語言環境概述
Gcc使用方法
Gdb調試技術
Autoconf
Automake
Makefile
代碼優化 熟悉Linux系統下的開發環境
熟悉Gcc編譯器
熟悉Makefile規則編寫Hello,World程序
使用 make命令編譯程序
編寫帶有一個循環的程序
調試一個有問題的程序
4、嵌入式系統開發基礎
嵌入式系統概述
交叉編譯
配置TFTP服務
配置NFS服務
下載Bootloader和內核
嵌入式Linux應用軟體開發流程
熟悉嵌入式系統概念以及開發流程
建立嵌入式系統開發環境製作cross_gcc工具鏈
編譯並下載U-boot
編譯並下載Linux內核
編譯並下載Linux應用程序
嵌入式系統移植
Linux內核代碼
平台相關代碼分析
ARM平台介紹
平台移植的關鍵技術
移植Linux內核到 ARM平台 了解移植的概念
能夠移植Linux內核移植Linux2.6內核到 ARM9開發板
5、嵌入式 Linux 下串口通信
串列I/O的基本概念
嵌入式Linux應用軟體開發流程
Linux系統的文件和設備
與文件相關的系統調用
配置超級終端和MiniCOM 能夠熟悉進行串口通信
熟悉文件I/O 編寫串口通信程序
編寫多串口通信程序
6、嵌入式系統中多進程程序設計
Linux系統進程概述
嵌入式系統的進程特點
進程操作
守護進程
相關的系統調用了解Linux系統中進程的概念
能夠編寫多進程程序編寫多進程程序
編寫一個守護進程程序
sleep系統調用任務管理、同步與通信 Linux任務概述
任務調度
管道
信號
共享內存
任務管理 API 了解Linux系統任務管理機制
熟悉進程間通信的幾種方式
熟悉嵌入式Linux中的任務間同步與通信
編寫一個簡單的管道程序實現文件傳輸
編寫一個使用共享內存的程序
7、嵌入式系統中多線程程序設計
線程的基礎知識
多線程編程方法
線程應用中的同步問題了解線程的概念
能夠編寫簡單的多線程程序編寫一個多線程程序
8、嵌入式 Linux 網路編程
網路基礎知識
嵌入式Linux中TCP/IP網路結構
socket 編程
常用 API函數
分析Ping命令的實現
基本UDP套介面編程
許可證管理
PPP協議
GPRS 了解嵌入式Linux網路體系結構
能夠進行嵌入式Linux環境下的socket 編程
熟悉UDP協議、PPP協議
熟悉GPRS 使用socket 編寫代理伺服器
使用socket 編寫路由器
編寫許可證伺服器
指出TCP和UDP的優缺點
編寫一個web伺服器
編寫一個運行在 ARM平台的網路播放器
9、GUI 程序開發
GUI基礎
嵌入式系統GUI類型
編譯QT
進行QT開發熟悉嵌入式系統常用的GUI
能夠進行QT編程使用QT編寫「Hello，World」程序
調試一個加入信號/槽的實例
通過重載QWidget 類方法處理事件
10、Linux 字元設備驅動程序
設備驅動程序基礎知識
Linux系統的模塊
字元設備驅動分析
fs_operation結構
載入驅動程序了解設備驅動程序的概念
了解Linux字元設備驅動程序結構
能夠編寫字元設備驅動程序編寫Skull驅動
編寫鍵盤驅動
編寫I/O驅動
分析一個看門狗驅動程序
對比Linux2.6內核與2.4內核中字元設備驅動的不同
Linux 塊設備驅動程序塊設備驅動程序工作原理
典型的塊設備驅動程序分析
塊設備的讀寫請求隊列了解Linux塊設備驅動程序結構
能夠編寫簡單的塊設備驅動程序比較字元設備與塊設備的異同
編寫MMC卡驅動程序
分析一個文件系統
對比Linux2.6內核與2.4內核中塊設備驅動的不同
11、文件系統
虛擬文件系統
文件系統的建立
ramfs內存文件系統
proc文件系統
devfs 文件系統
MTD技術簡介
MTD塊設備初始化
MTD塊設備的讀寫操作了解Linux系統的文件系統
了解嵌入式Linux的文件系統
了解MTD技術
能夠編寫簡單的文件系統為 ARM9開發板添加 MTD支持
移植JFFS2文件系統
通過proc文件系統修改操作系統參數
分析romfs 文件系統源代碼
創建一個cramfs 文件系統
⑦ 如何編寫linux daemon進程
守護進程的編程要點 :1. 在後台運行。
為避免掛起控制終端將Daemon放入後台執行。方法是在進程中調用fork使父進程終止，讓Daemon在子進程中後台執行。
if(pid=fork())
exit(0);//是父進程，結束父進程，子進程繼續
2. 脫離控制終端，登錄會話和進程組
有必要先介紹一下Linux中的進程與控制終端，登錄會話和進程組之間的關系：進程屬於一個進程組，進程組號（GID）就是進程組長的進程號（PID）。登錄會話可以包含多個進程組。這些進程組共享一個控制終端。這個控制終端通常是創建進程的登錄終端。
控制終端，登錄會話和進程組通常是從父進程繼承下來的。我們的目的就是要擺脫它們，使之不受它們的影響。方法是在第1點的基礎上，調用setsid()使進程成為會話組長：
setsid();
說明：當進程是會話組長時setsid()調用失敗。但第一點已經保證進程不是會話組長。setsid()調用成功後，進程成為新的會話組長和新的進程組長，並與原來的登錄會話和進程組脫離。由於會話過程對控制終端的獨占性，進程同時與控制終端脫離。
3. 禁止進程重新打開控制終端
現在，進程已經成為無終端的會話組長。但它可以重新申請打開一個控制終端。可以通過使進程不再成為會話組長來禁止進程重新打開控制終端：
if(pid=fork())
exit(0);//結束第一子進程，第二子進程繼續（第二子進程不再是會話組長）
4. 關閉打開的文件描述符
進程從創建它的父進程那裡繼承了打開的文件描述符。如不關閉，將會浪費系統資源，造成進程所在的文件系統無法卸下以及引起無法預料的錯誤。按如下方法關閉它們：
for(i=0;i 關閉打開的文件描述符close(i);>
5. 改變當前工作目錄
進程活動時，其工作目錄所在的文件系統不能卸下。一般需要將工作目錄改變到根目錄。對於需要轉儲核心，寫運行日誌的進程將工作目錄改變到特定目錄如/tmpchdir("/")
6. 重設文件創建掩模
進程從創建它的父進程那裡繼承了文件創建掩模。它可能修改守護進程所創建的文件的存取位。為防止這一點，將文件創建掩模清除：umask(0);
7. 處理SIGCHLD信號
處理SIGCHLD信號並不是必須的。但對於某些進程，特別是伺服器進程往往在請求到來時生成子進程處理請求。如果父進程不等待子進程結束，子進程將成為 僵屍進程（zombie）從而佔用系統資源。如果父進程等待子進程結束，將增加父進程的負擔，影響伺服器進程的並發性能。在Linux下可以簡單地將 SIGCHLD信號的操作設為SIG_IGN。
signal(SIGCHLD,SIG_IGN);
這樣，內核在子進程結束時不會產生僵屍進程。這一點與BSD4不同，BSD4下必須顯式等待子進程結束才能釋放僵屍進程。
⑧ linux下多進程或者多線程編程的問題。新手，望指教！
你好，多進程或多線程，都不會阻塞當前語句代碼。為了您的理解，我就大膽舉下面兩個例子：
多進程：你可以看成是本來是一條路的，現在從中間拆成兩條，然後每一條路都有屬於自己這條路的代碼在運行。
多線程：你可以看成是一條路，然後分出車道，比如左車道和右車道甚至是停車道，然後每條車道都單獨通車，其他車道的不能對這條車道進行干擾。
所以，把一條路從中間拆成兩條，成本是很高的。但是把一條路分車道，成本就不是很高了。
對於您提出的main函數的疑問，當main函數最後執行完畢，程序退出後，所有的進程包括線程，都會被關閉的，哪怕你的程序中沒有關閉，操作系統也會幫你關閉的，現在的操作系統都非常的完善了。當然，也存在有線程或進程不被釋放的特殊情況，最好在編程中要記得釋放。
⑨ linux進程編程
哪裡有NULL指針
⑩ Linux編程的幾個重要知識點
第一階段：linux基礎入門
Linux基礎入門主要包括： Linux硬體基礎、Linux發展歷史、Linux系統安裝、xshell連接、xshell優化、SSH遠程連接故障問題排查、L inux基礎優化、Linux目錄結構知識、Linux文件屬性、Linux通配符、正則表達式、Linux系統許可權等
第二階段：linux系統管理進階
linux系統管理進階包括：Linux定時任務、Linux用戶管理、Linux磁碟與文件系統、Linux三劍客之sed命令等。
第三階段：Linux Shell基礎
Linux Shell基礎包括：Shell編程基礎、Linux三劍客之awk命令等。
第四階段：Linux網路基礎
第五階段：Linux網路服務
Linux網路服務包括：集群實戰架構開始及環境准備、rsync數據同步服務、Linux全網備份項目、nfs網路存儲服務精講、inotify/sersync實時數據同步/nfs存儲實時備份項目等。
第六階段：Linux重要網路服務
Linux重要網路服務包括：http協議/www服務基礎、nginx web介紹及基礎實踐、nginx web、lnmp環境部署/資料庫異機遷移/共享數據異機遷移到NFS系統、nginx負載均衡、keepalived高可用等。
第七階段：Ansible自動化運維與Zabbix監控
Ansible自動化運維與Zabbix監控包括： SSH服務秘鑰認證、ansible批量自動化管理集群、 zabbix監控等。
第九階段：大規模集群高可用服務(Lvs、Keepalived)
第十階段：Java Tomcat服務及防火牆Iptables
第十一階段：MySQL DBA高級應用實踐
MySQL DBA高級應用實踐包括：MySQL資料庫入門基礎命令、MySQL資料庫進階備份恢復、MySQL資料庫深入事務引擎、MySQL資料庫優化SQL語句優化、MySQL資料庫集群主從復制/讀寫分離、MySQL資料庫高可用/mha/keepalved等。
第十二階段：高性能資料庫Redis和Memcached課程
第十三階段：Linux大規模集群架構構建（200台）
第十四階段：Linux Shell編程企業案例實戰
第十五階段：企業級代碼發布上線方案（SVN和Git）
第十六階段企業級Kvm虛擬化與OpenStack雲計算
第十七階段公有雲阿里雲8大組件構建集群實戰
第十八階段：Docker技術企業應用實踐
第十九階段：Python自動化入門及進階
第二十階段：職業規劃與高薪就業指導