Linuxでのプロセス間通信の紹介

プロセス間通信（IPC）は、プロセススレッド間でデータを交換するための一連のメソッドです。 プロセスは、同じコンピューターとネットワークで接続された異なるコンピューターの両方で起動できます。 IPCには、「signal」、「socket」、「semaphore」、「file」、「message」など、いくつかのタイプがあります...



この記事では、3種類のIPCのみを検討します。

1. 名前付きパイプ
2. 共有メモリ
3. セマフォ

余談：この記事は教育的なものであり、まだシステムプログラミングの道を歩んでいる人々を対象としています。 その主なアイデアは、POSIX互換OS上のプロセス間のさまざまなやり取り方法に精通することです。

名前付きパイプ

メッセージを送信するには、ソケット、チャネル、Dバス、およびその他の技術のメカニズムを使用できます。 隅々にあるソケットについて読んだり、D-busに関する別の記事を書いたりすることができます。 そのため、私はPOSIX規格に適合した低音技術に専念し、実例を紹介することにしました。



名前付きパイプを介してメッセージを渡すことを検討してください。 概略的に、転送は次のようになります。



名前付きパイプを作成するには、関数mkfifo（）を使用します。

#include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この関数はpathnameという名前の特別なFIFOファイルを作成し、 modeパラメーターはファイルへのアクセス権を設定します。

注： modeは 、次のように現在のumask値と組み合わせて使用​​されます： （ mode ＆〜umask） 。 この操作の結果は、作成するファイルの新しいumask値になります。 このため、0777（ S_IRWXO | S_IRWXG | S_IRWXU ）を使用して、現在のマスクの1ビットを上書きしません。

ファイルが作成されると、通常のファイルと同様に、どのプロセスでもこのファイルを読み取りまたは書き込み用に開くことができます。 ただし、ファイルを正しく使用するには、2つのプロセス/スレッドで同時に開く必要があります。1つはデータの受信（ファイルの読み取り）で、もう1つは転送（ファイルの書き込み）です。



FIFOファイルが正常に作成されると、 mkfifo（）は0（ゼロ）を返します。 エラーが発生した場合、関数は-1を返し 、エラーコードをerrno変数に設定します。



チャネルの作成中に発生する典型的なエラー：

• EACCES- パス名 pathのいずれかのディレクトリで実行（実行）する権限がありません
• EEXIST-ファイルがシンボリックリンクであっても、 パス名ファイルは既に存在します
• ENOENT - pathnameに記載されているディレクトリが存在しないか、リンクが壊れています
• ENOSPC-新しいファイルを作成するスペースがありません
• ENOTDIR- パス名に記載されているディレクトリの1つが実際には1つではありません
• EROFS-読み取り専用ファイルシステムでFIFOファイルを作成しようとする試み

作成されたファイルの読み取りと書き込みは、 read（）およびwrite（）関数を使用して行われます。

例

mkfifo.c

 #include <sys/stat.h> #include <fcntl.h> #include <string.h> #include <stdio.h> #define NAMEDPIPE_NAME "/tmp/my_named_pipe" #define BUFSIZE 50 int main (int argc, char ** argv) { int fd, len; char buf[BUFSIZE]; if ( mkfifo(NAMEDPIPE_NAME, 0777) ) { perror("mkfifo"); return 1; } printf("%s is created\n", NAMEDPIPE_NAME); if ( (fd = open(NAMEDPIPE_NAME, O_RDONLY)) <= 0 ) { perror("open"); return 1; } printf("%s is opened\n", NAMEDPIPE_NAME); do { memset(buf, '\0', BUFSIZE); if ( (len = read(fd, buf, BUFSIZE-1)) <= 0 ) { perror("read"); close(fd); remove(NAMEDPIPE_NAME); return 0; } printf("Incomming message (%d): %s\n", len, buf); } while ( 1 ); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

[ ダウンロード ]



読み取り専用でファイルを開きます（ O_RDONLY ）。 また、FIFOファイル専用に設計されたO_NONBLOCK修飾子を使用して、ファイルが書き込み用に開かれたときに待機しないようにすることもできます。 しかし、上記のコードでは、このメソッドは不便です。



プログラムをコンパイルしてから実行します。

 $ gcc -o mkfifo mkfifo.c $ ./mkfifo
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

隣接するターミナルウィンドウで、次の操作を行います。

 $ echo 'Hello, my named pipe!' > /tmp/my_named_pipe
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

その結果、プログラムから次の出力が表示されます。

 $ ./mkfifo /tmp/my_named_pipe is created /tmp/my_named_pipe is opened Incomming message (22): Hello, my named pipe! read: Success
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

共有メモリ

次のタイプのプロセス間通信は共有メモリです。 概略的には、2つのプロセスによって同時にアクセスされるメモリ内の特定の名前付き領域として表示します。



共有メモリを割り当てるには、POSIX shm_open（）関数を使用します。

 #include <sys/mman.h> int shm_open(const char *name, int oflag, mode_t mode);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この関数は、メモリオブジェクトに関連付けられているファイル記述子を返します。 この記述子は、後で他の関数（たとえば、 mmap（）またはmprotect（） ）で使用できます。



オブジェクトが切断/削除されるまで（ shm_unlink（） ）、メモリオブジェクトの完全性は、それに関連付けられているすべてのデータを含めて保持されます。 これは、いずれかのプロセスでshm_unlink（）を明示的に呼び出すまで、どのプロセスも（名前を知っていれば）メモリオブジェクトにアクセスできることを意味します。



oflag変数は、次のフラグのビット単位のORです。

• O_RDONLY-読み取りアクセスのみで開く
• O_RDWR-読み取りおよび書き込み権限で開く
• O_CREAT-オブジェクトが既に存在する場合、フラグの効果はありません。 そうでない場合は、オブジェクトが作成され、モードに従ってアクセス権が設定されます。
• O_EXCL-このフラグをO_CREATEと組み合わせて設定すると、共有メモリセグメントが既に存在する場合、shm_open関数はエラーを返します。

modeパラメーターの値の設定方法については、前の段落「メッセージの受け渡し」で詳しく説明しています。



共有メモリオブジェクトを作成した後、 ftruncate（）を呼び出して共有メモリのサイズを設定します。 関数の入力には、オブジェクトのファイル記述子と必要なサイズがあります。

例

次のコードは、共有メモリの作成、変更、および削除を示しています。 また、共有メモリを作成した後、プログラムがどのように終了するかを示していますが、次に起動するときは、 shm_unlink（）が実行されるまでアクセスできます。

shm_open.c

 #include <unistd.h> #include <sys/types.h> #include <sys/mman.h> #include <fcntl.h> #include <stdio.h> #include <string.h> #define SHARED_MEMORY_OBJECT_NAME "my_shared_memory" #define SHARED_MEMORY_OBJECT_SIZE 50 #define SHM_CREATE 1 #define SHM_PRINT 3 #define SHM_CLOSE 4 void usage(const char * s) { printf("Usage: %s <create|write|read|unlink> ['text']\n", s); } int main (int argc, char ** argv) { int shm, len, cmd, mode = 0; char *addr; if ( argc < 2 ) { usage(argv[0]); return 1; } if ( (!strcmp(argv[1], "create") || !strcmp(argv[1], "write")) && (argc == 3) ) { len = strlen(argv[2]); len = (len<=SHARED_MEMORY_OBJECT_SIZE)?len:SHARED_MEMORY_OBJECT_SIZE; mode = O_CREAT; cmd = SHM_CREATE; } else if ( ! strcmp(argv[1], "print" ) ) { cmd = SHM_PRINT; } else if ( ! strcmp(argv[1], "unlink" ) ) { cmd = SHM_CLOSE; } else { usage(argv[0]); return 1; } if ( (shm = shm_open(SHARED_MEMORY_OBJECT_NAME, mode|O_RDWR, 0777)) == -1 ) { perror("shm_open"); return 1; } if ( cmd == SHM_CREATE ) { if ( ftruncate(shm, SHARED_MEMORY_OBJECT_SIZE+1) == -1 ) { perror("ftruncate"); return 1; } } addr = mmap(0, SHARED_MEMORY_OBJECT_SIZE+1, PROT_WRITE|PROT_READ, MAP_SHARED, shm, 0); if ( addr == (char*)-1 ) { perror("mmap"); return 1; } switch ( cmd ) { case SHM_CREATE: memcpy(addr, argv[2], len); addr[len] = '\0'; printf("Shared memory filled in. You may run '%s print' to see value.\n", argv[0]); break; case SHM_PRINT: printf("Got from shared memory: %s\n", addr); break; } munmap(addr, SHARED_MEMORY_OBJECT_SIZE); close(shm); if ( cmd == SHM_CLOSE ) { shm_unlink(SHARED_MEMORY_OBJECT_NAME); } return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

[ ダウンロード ]



メモリオブジェクトを作成した後、 ftruncate（）を呼び出して必要な共有メモリのサイズを設定します。 次に、 mmap（）を使用して共有メモリにアクセスしました。 （一般的に、 mmap（）呼び出し自体を使用しても共有メモリを作成できます。しかし、 shm_open（）呼び出しの違いは、コンピューターが削除または再起動されるまでメモリが割り当てられたままになることです。）



今回は、 -lrtオプションを使用してコードをコンパイルする必要があります。

 $ gcc -o shm_open -lrt shm_open.c
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

何が起こったのか見てみましょう：

 $ ./shm_open create 'Hello, my shared memory!' Shared memory filled in. You may run './shm_open print' to see value. $ ./shm_open print Got from shared memory: Hello, my shared memory! $ ./shm_open create 'Hello!' Shared memory filled in. You may run './shm_open print' to see value. $ ./shm_open print Got from shared memory: Hello! $ ./shm_open close $ ./shm_open print shm_open: No such file or directory
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プログラムでcreate引数を使用して、共有メモリの作成とその内容の変更の両方を行います。



メモリオブジェクトの名前を知っていれば、共有メモリの内容を変更できます。 しかし、 一度shm_unlink（）を呼び出すと、メモリは使用できなくなり、 O_CREATEパラメーターなしでshm_open（）は「No such file or directory」というエラーを返します。

セマフォ

セマフォは、スレッドを同期し、複数のスレッド/プロセスの共有メモリ（グローバル変数など）への同時アクセスを制御するために最も一般的に使用される方法です。 セマフォの場合のプロセス間の相互作用は、プロセスが同じデータセットで動作し、このデータに応じて動作を調整することです。



セマフォには2つのタイプがあります。

1. カウンタ（セマフォをカウント）を備えたセマフォ。これは、それらにアクセスするプロセスのリソースの制限を決定します。
2. 2つの状態「0」または「1」を持つバイナリセマフォ（「ビジー」または「ビジーではない」）

両方のタイプのセマフォを検討してください。

カウンター付きのセマフォ

カウンタを使用したセマフォの意味は、特定のリソースへのアクセスを特定の数のプロセスのみに許可することです。 リソースが解放されると、残りは順番に待機します。



したがって、セマフォを実装するには、POSIX関数sem_open（）を使用します。

 #include <semaphore.h> sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

セマフォを作成する関数では、特定のルールと制御フラグに従って構築されたセマフォの名前を渡します。 このようにして、名前付きセマフォを取得します。

セマフォの名前は次のように構成されます。先頭には記号「/」（スラッシュ）があり、その後にラテン文字が続きます。 スラッシュ記号は適用されなくなりました。 セマフォ名の長さは最大251文字です。



セマフォを作成する必要がある場合、 O_CREATE制御フラグが渡されます。 既存のセマフォの使用を開始するには、 oflagはゼロです。 O_EXCLフラグがO_CREATEフラグと一緒に渡される場合、指定された名前のセマフォが既に存在する場合、 sem_open（）関数はエラーを返します。



modeパラメーターは、前の章で説明したのと同じ方法で許可を設定します。 そして、 値変数はセマフォの初期値を初期化します。 指定された名前のセマフォが既に存在し、 sem_open（）が O_CREATEフラグとともに呼び出される場合、 モードパラメータと値パラメータの両方は無視されます。



既存のセマフォをすばやく開くには、次の構造を使用します。

 #include <semaphore.h> sem_t *sem_open(const char *name, int oflag);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

セマフォ名と制御フラグのみが示されています。

カウンターを使用したセマフォの例

セマフォを使用してプロセスを同期する例を考えてみましょう。 この例では、1つのプロセスがセマフォの値を増やし、さらに実行を続けるために2番目のプロセスがそれをリセットするのを待ちます。

sem_open.c

 #include <fcntl.h> #include <sys/stat.h> #include <semaphore.h> #include <stdio.h> #define SEMAPHORE_NAME "/my_named_semaphore" int main(int argc, char ** argv) { sem_t *sem; if ( argc == 2 ) { printf("Dropping semaphore...\n"); if ( (sem = sem_open(SEMAPHORE_NAME, 0)) == SEM_FAILED ) { perror("sem_open"); return 1; } sem_post(sem); perror("sem_post"); printf("Semaphore dropped.\n"); return 0; } if ( (sem = sem_open(SEMAPHORE_NAME, O_CREAT, 0777, 0)) == SEM_FAILED ) { perror("sem_open"); return 1; } printf("Semaphore is taken.\nWaiting for it to be dropped.\n"); if (sem_wait(sem) < 0 ) perror("sem_wait"); if ( sem_close(sem) < 0 ) perror("sem_close"); return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

[ ダウンロード ]



1つのコンソールで、次を実行します。

 $ ./sem_open Semaphore is taken. Waiting for it to be dropped. <--       sem_wait: Success sem_close: Success
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

隣接するコンソールで、次を実行します。

 $ ./sem_open 1 Dropping semaphore... sem_post: Success Semaphore dropped.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

バイナリセマフォ

sem_open関数も使用されるバイナリセマフォの代わりに、ミューテックスと呼ばれるより一般的に使用されるセマフォを検討します。



ミューテックスは、バイナリセマフォ（つまり、ビジー状態とビジー状態ではない2つの状態を持つセマフォ）と本質的に同じです。 ただし、「mutex」という用語は、2つのプロセスが共有データ/変数を同時に使用しないように保護するスキームを説明するためによく使用されます。 「バイナリセマフォ」という用語は、単一のリソースへのアクセスを制限する構造を説明するためによく使用されます。 つまり、1つのプロセスがセマフォを「占有」し、他のプロセスがセマフォを「解放」するバイナリセマフォが使用されます。 ミューテックスは、それを占有していた同じプロセス/スレッドによって解放されます。



たとえば、多くのクライアントがアクセスできるデータベースなど、ミューテックスを使用せずに記述することは不可能です。



ミューテックスを使用するには、pthread_mutex_init（）関数を呼び出す必要があります。

 #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この関数は、 mutexattr属性を使用してmutex（変数mutex ）を初期化します。 mutexattrがNULLの場合、mutexはデフォルト値に初期化されます。 関数が成功した場合（戻りコード0）、mutexは初期化され、「フリー」であると見なされます。



発生する可能性のある典型的なエラー：

• EAGAIN-ミューテックスを初期化するのに十分なリソース（メモリを除く）
• ENOMEM-十分なメモリがありません
• EPERM-操作を実行する権限がありません
• EBUSY-既に初期化されているが、破壊されていないミューテックスを初期化する試み
• EINVAL - mutexattr値が無効です

ミューテックスを占有または解放するには、次の関数を使用します。

 int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

mutexがまだビジーでない場合、 pthread_mutex_lock（）関数はそれを取得し 、所有者になり、すぐに終了します。 ミューテックスがビジーの場合、プロセスのさらなる実行をブロックし、ミューテックスが解放されるのを待ちます。

pthread_mutex_trylock（）関数の動作は、 pthread_mutex_lock（）関数と同じですが、1つの例外があります。 ミューテックスがビジーの場合はプロセスをブロックせず、 EBUSYコードを返します。

pthread_mutex_unlock（）関数は、ビジーなミューテックスを解放します。



pthread_mutex_lock（）のリターンコード：

• EINVAL-ミューテックスが正しく初期化されていません
• EDEADLK-ミューテックスは現在のプロセスですでに使用されています。

pthread_mutex_trylock（）のリターンコード：

• EBUSY-ミューテックスはすでに使用されています
• EINVAL-ミューテックスが正しく初期化されていません

pthread_mutex_unlock（）のリターンコード：

• EINVAL-ミューテックスが正しく初期化されていません
• EPERM-呼び出しプロセスはミューテックスの所有者ではありません

ミューテックスの例

mutex.c

 #include <stdio.h> #include <pthread.h> #include <unistd.h> #include <errno.h> static int counter; // shared resource static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; void incr_counter(void *p) { do { usleep(10); // Let's have a time slice between mutex locks pthread_mutex_lock(&mutex); counter++; printf("%d\n", counter); sleep(1); pthread_mutex_unlock(&mutex); } while ( 1 ); } void reset_counter(void *p) { char buf[10]; int num = 0; int rc; pthread_mutex_lock(&mutex); // block mutex just to show message printf("Enter the number and press 'Enter' to initialize the counter with new value anytime.\n"); sleep(3); pthread_mutex_unlock(&mutex); // unblock blocked mutex so another thread may work do { if ( gets(buf) != buf ) return; // NO fool-protection ! Risk of overflow ! num = atoi(buf); if ( (rc = pthread_mutex_trylock(&mutex)) == EBUSY ) { printf("Mutex is already locked by another process.\nLet's lock mutex using pthread_mutex_lock().\n"); pthread_mutex_lock(&mutex); } else if ( rc == 0 ) { printf("WOW! You are on time! Congratulation!\n"); } else { printf("Error: %d\n", rc); return; } counter = num; printf("New value for counter is %d\n", counter); pthread_mutex_unlock(&mutex); } while ( 1 ); } int main(int argc, char ** argv) { pthread_t thread_1; pthread_t thread_2; counter = 0; pthread_create(&thread_1, NULL, (void *)&incr_counter, NULL); pthread_create(&thread_2, NULL, (void *)&reset_counter, NULL); pthread_join(thread_2, NULL); return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

[ ダウンロード ]



この例は、共有変数への2つのスレッドの共有を示しています。 自動モードの1つのスレッド（最初のスレッド）は、 カウンター変数を常に1ずつ増やしながら、この変数を1秒間占有します。 この最初のスレッドは、10ミリ秒だけカウント変数への2回目のアクセスを許可してから、再び1秒かかります。 2番目のスレッドでは、端末から変数の新しい値を入力することが提案されています。



ミューテックステクノロジを使用していなかった場合、2つのストリームに同時にアクセスしている間、グローバル変数にどの値が含まれるかはわかりません。 また、起動時に、 pthread_mutex_lock（）とpthread_mutex_trylock（）の違いが明らかになります。



-lpthread追加パラメーターを使用してコードをコンパイルする必要があります。

 $ gcc -o mutex -lpthread mutex.c
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ターミナルウィンドウに新しい値を入力するだけで、変数の値を開始して変更します。

 $ ./mutex Enter the number and press 'Enter' to initialize the counter with new value anytime. 1 2 3 30 <Enter> <---    Mutex is already locked by another process. Let's lock mutex using pthread_mutex_lock(). New value for counter is 30 31 32 33 1 <Enter> <---    Mutex is already locked by another process. Let's lock mutex using pthread_mutex_lock(). New value for counter is 1 2 3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

結論の代わりに

次の記事では、d-busおよびRPCテクノロジーについて説明します。 興味のある方はお知らせください。

ありがとう



UPD：セマフォに関する第3章を更新しました。 ミューテックスに関するサブチャプターを追加しました。