// パイプのCプログラム例
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
 
int main() {
    int pipefd[2];  // pipefd[0] = 読み込み端, pipefd[1] = 書き込み端
 
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
 
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
 
    if (pid == 0) {
        // 子プロセス: 読み込み側
        close(pipefd[1]);  // 書き込み端を閉じる
 
        char buf[256];
        ssize_t n;
        while ((n = read(pipefd[0], buf, sizeof(buf) - 1)) > 0) {
            buf[n] = '\0';
            printf("子プロセスが受信: %s\n", buf);
        }
 
        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    } else {
        // 親プロセス: 書き込み側
        close(pipefd[0]);  // 読み込み端を閉じる
 
        const char *msg = "Hello from parent!";
        write(pipefd[1], msg, strlen(msg));
 
        close(pipefd[1]);  // EOFを送信
        wait(NULL);        // 子プロセスの終了を待つ
    }
 
    return 0;
}

// 双方向通信には2本のパイプが必要
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
int main() {
    int pipe_parent_to_child[2];  // 親→子
    int pipe_child_to_parent[2];  // 子→親
 
    pipe(pipe_parent_to_child);
    pipe(pipe_child_to_parent);
 
    pid_t pid = fork();
    if (pid == 0) {
        // 子プロセス
        close(pipe_parent_to_child[1]);
        close(pipe_child_to_parent[0]);
 
        char buf[256];
        read(pipe_parent_to_child[0], buf, sizeof(buf));
        printf("子が受信: %s\n", buf);
 
        const char *reply = "Hello from child!";
        write(pipe_child_to_parent[1], reply, strlen(reply));
 
        close(pipe_parent_to_child[0]);
        close(pipe_child_to_parent[1]);
        exit(0);
    } else {
        // 親プロセス
        close(pipe_parent_to_child[0]);
        close(pipe_child_to_parent[1]);
 
        const char *msg = "Hello from parent!";
        write(pipe_parent_to_child[1], msg, strlen(msg));
 
        char buf[256];
        ssize_t n = read(pipe_child_to_parent[0], buf, sizeof(buf) - 1);
        buf[n] = '\0';
        printf("親が受信: %s\n", buf);
 
        close(pipe_parent_to_child[1]);
        close(pipe_child_to_parent[0]);
    }
    return 0;
}

# Pythonでの名前付きパイプの例
 
# サーバー側（読み込み）
import os
 
fifo_path = "/tmp/myfifo"
 
# FIFOの作成（既に存在する場合はスキップ）
if not os.path.exists(fifo_path):
    os.mkfifo(fifo_path)
 
print("クライアントの接続を待っています...")
with open(fifo_path, 'r') as fifo:
    while True:
        line = fifo.readline()
        if not line:
            break
        print(f"受信: {line.strip()}")
 
# クライアント側（書き込み）
with open(fifo_path, 'w') as fifo:
    fifo.write("Hello from client!\n")
    fifo.flush()

# シグナルの送信方法
 
# kill コマンド（名前に反してシグナル全般を送信）
kill -TERM 1234           # PID 1234にSIGTERM送信
kill -9 1234              # PID 1234をSIGKILL（強制終了）
kill -HUP $(cat /var/run/nginx.pid)  # nginx設定再読込
kill -USR1 $(pidof dd)    # ddの進捗表示
 
# killall: プロセス名で指定
killall -TERM firefox     # firefoxの全プロセスにSIGTERM
killall -HUP syslogd      # syslogd に設定再読込
 
# pkill: パターンマッチで指定
pkill -f "python server.py"  # コマンドライン全体でマッチ
pkill -u username            # 特定ユーザーの全プロセス
 
# プロセスグループへの送信
kill -TERM -1234             # PGID 1234の全プロセスに送信
kill -TERM 0                 # 自分と同じプロセスグループに送信
 
# セッション全体への送信
pkill -s 1234                # セッションID 1234の全プロセス

// C言語でのシグナルハンドリング（sigaction推奨）
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
 
// volatile sig_atomic_t: シグナルハンドラと安全に共有できる型
volatile sig_atomic_t got_sigterm = 0;
volatile sig_atomic_t got_sighup = 0;
 
void sigterm_handler(int signum) {
    got_sigterm = 1;
    // 注意: シグナルハンドラ内ではasync-signal-safe関数のみ使用可能
    // printf(), malloc(), free() 等は使用不可
    // write() は使用可能
    const char msg[] = "SIGTERM received\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);
}
 
void sighup_handler(int signum) {
    got_sighup = 1;
}
 
int main() {
    // sigaction構造体の設定
    struct sigaction sa_term, sa_hup;
 
    // SIGTERM ハンドラ
    memset(&sa_term, 0, sizeof(sa_term));
    sa_term.sa_handler = sigterm_handler;
    sigemptyset(&sa_term.sa_mask);       // ハンドラ実行中にブロックする追加シグナルなし
    sa_term.sa_flags = 0;                // フラグなし
    sigaction(SIGTERM, &sa_term, NULL);
 
    // SIGHUP ハンドラ
    memset(&sa_hup, 0, sizeof(sa_hup));
    sa_hup.sa_handler = sighup_handler;
    sigemptyset(&sa_hup.sa_mask);
    sa_hup.sa_flags = SA_RESTART;        // シグナルで中断されたシステムコールを自動再開
    sigaction(SIGHUP, &sa_hup, NULL);
 
    // SIGPIPE を無視（ソケット/パイプ切断時の予期しない終了を防ぐ）
    struct sigaction sa_pipe;
    memset(&sa_pipe, 0, sizeof(sa_pipe));
    sa_pipe.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &sa_pipe, NULL);
 
    printf("PID: %d. SIGTERM or SIGHUP を送信してください\n", getpid());
 
    while (!got_sigterm) {
        if (got_sighup) {
            printf("設定を再読み込みしています...\n");
            got_sighup = 0;
            // 設定ファイルの再読込処理
        }
        sleep(1);
    }
 
    printf("正常終了処理中...\n");
    // クリーンアップ処理（ファイルクローズ、一時ファイル削除等）
    return 0;
}

# Pythonでのシグナルハンドリング（実務的な例）
import signal
import sys
import os
import time
import logging
from contextlib import contextmanager
 
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
logger = logging.getLogger(__name__)
 
class GracefulShutdown:
    """グレースフルシャットダウンを管理するクラス"""
 
    def __init__(self):
        self.shutdown_requested = False
        self.connections = []
 
        # シグナルハンドラの登録
        signal.signal(signal.SIGTERM, self._handle_signal)
        signal.signal(signal.SIGINT, self._handle_signal)
        signal.signal(signal.SIGHUP, self._handle_sighup)
 
    def _handle_signal(self, signum, frame):
        sig_name = signal.Signals(signum).name
        logger.info(f"{sig_name} を受信。シャットダウンを開始します...")
        self.shutdown_requested = True
 
    def _handle_sighup(self, signum, frame):
        logger.info("SIGHUP を受信。設定を再読み込みします...")
        self.reload_config()
 
    def reload_config(self):
        """設定ファイルの再読み込み"""
        logger.info("設定ファイルを再読み込み中...")
        # config = load_config("/etc/myapp/config.yaml")
 
    def cleanup(self):
        """クリーンアップ処理"""
        logger.info("接続をクローズしています...")
        for conn in self.connections:
            try:
                conn.close()
            except Exception as e:
                logger.error(f"接続クローズ失敗: {e}")
 
        logger.info("一時ファイルを削除しています...")
        # cleanup_temp_files()
 
        logger.info("クリーンアップ完了")
 
    def run(self):
        """メインループ"""
        logger.info(f"PID: {os.getpid()} で起動しました")
 
        while not self.shutdown_requested:
            try:
                # メイン処理
                self.process_work()
                time.sleep(0.1)
            except Exception as e:
                logger.error(f"エラー: {e}")
 
        self.cleanup()
        logger.info("正常終了しました")
 
    def process_work(self):
        """実際のビジネスロジック"""
        pass
 
if __name__ == "__main__":
    app = GracefulShutdown()
    app.run()

// POSIX共有メモリ + セマフォの実装例
 
// 共通ヘッダ（shared_data.h）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <semaphore.h>
 
#define SHM_NAME "/my_shared_mem"
#define SEM_NAME "/my_semaphore"
#define SHM_SIZE 4096
 
typedef struct {
    int counter;
    char message[256];
    int ready;  // フラグ
} SharedData;
 
// プロデューサー（書き込み側）
int producer() {
    // 共有メモリの作成
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, sizeof(SharedData));
 
    SharedData *data = mmap(NULL, sizeof(SharedData),
                           PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);
 
    // セマフォの作成
    sem_t *sem = sem_open(SEM_NAME, O_CREAT, 0666, 1);
 
    for (int i = 0; i < 100; i++) {
        sem_wait(sem);  // ロック取得
        data->counter = i;
        snprintf(data->message, sizeof(data->message), "Message #%d", i);
        data->ready = 1;
        sem_post(sem);  // ロック解放
        usleep(10000);  // 10ms待機
    }
 
    munmap(data, sizeof(SharedData));
    sem_close(sem);
    return 0;
}
 
// コンシューマー（読み込み側）
int consumer() {
    int fd = shm_open(SHM_NAME, O_RDONLY, 0666);
    SharedData *data = mmap(NULL, sizeof(SharedData),
                           PROT_READ, MAP_SHARED, fd, 0);
    close(fd);
 
    sem_t *sem = sem_open(SEM_NAME, 0);
 
    while (1) {
        sem_wait(sem);
        if (data->ready) {
            printf("Counter: %d, Message: %s\n", data->counter, data->message);
            // data->ready = 0;  // 読み取り専用なので書けない
        }
        sem_post(sem);
        usleep(10000);
    }
 
    munmap(data, sizeof(SharedData));
    sem_close(sem);
    return 0;
}

// mmapによるファイルの読み書き例
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
 
int main() {
    const char *filepath = "/tmp/mmap_example.dat";
 
    // ファイルの作成と初期データの書き込み
    int fd = open(filepath, O_RDWR | O_CREAT | O_TRUNC, 0666);
    const char *initial = "Hello, mmap world!\n";
    write(fd, initial, strlen(initial));
 
    // ファイルサイズの取得
    struct stat st;
    fstat(fd, &st);
 
    // メモリマッピング
    char *mapped = mmap(NULL, st.st_size,
                       PROT_READ | PROT_WRITE,
                       MAP_SHARED, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }
    close(fd);  // マッピング後はfdを閉じてもOK
 
    // マッピング経由でデータを読む
    printf("Read via mmap: %s", mapped);
 
    // マッピング経由でデータを変更（ファイルに反映される）
    memcpy(mapped, "HELLO", 5);
 
    // 変更を確実にディスクに書き込む
    msync(mapped, st.st_size, MS_SYNC);
 
    // マッピング解除
    munmap(mapped, st.st_size);
 
    // ファイルを通常のI/Oで確認
    fd = open(filepath, O_RDONLY);
    char buf[256];
    read(fd, buf, sizeof(buf));
    printf("Read via read(): %s", buf);
    close(fd);
 
    unlink(filepath);
    return 0;
}

# Pythonでのmmap活用例
 
import mmap
import os
 
# 大きなファイルの効率的な検索
def search_large_file(filepath, pattern):
    """mmapを使った大きなファイルの高速検索"""
    with open(filepath, 'rb') as f:
        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
            pattern_bytes = pattern.encode()
            offset = 0
            results = []
            while True:
                pos = mm.find(pattern_bytes, offset)
                if pos == -1:
                    break
                # 行番号を計算
                line_num = mm[:pos].count(b'\n') + 1
                results.append((line_num, pos))
                offset = pos + 1
            return results
 
# プロセス間共有メモリ（Python 3.8+）
from multiprocessing import shared_memory
 
# 書き込み側
shm = shared_memory.SharedMemory(name='my_shared', create=True, size=1024)
shm.buf[0:5] = b'Hello'
print(f"共有メモリ名: {shm.name}")
 
# 読み込み側（別プロセス）
shm2 = shared_memory.SharedMemory(name='my_shared')
print(bytes(shm2.buf[0:5]))  # b'Hello'
shm2.close()
 
# クリーンアップ
shm.close()
shm.unlink()

# Unixドメインソケットサーバー/クライアントの例
 
import socket
import os
 
SOCKET_PATH = "/tmp/my_unix_socket"
 
# サーバー
def unix_server():
    # 既存のソケットファイルを削除
    if os.path.exists(SOCKET_PATH):
        os.unlink(SOCKET_PATH)
 
    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    server.bind(SOCKET_PATH)
    server.listen(5)
 
    # ソケットファイルのパーミッション設定
    os.chmod(SOCKET_PATH, 0o666)
 
    print(f"サーバー起動: {SOCKET_PATH}")
    try:
        while True:
            conn, addr = server.accept()
            print(f"接続受付")
 
            # ピア資格情報の取得（Linux固有）
            # creds = conn.getsockopt(socket.SOL_SOCKET,
            #                        socket.SO_PEERCRED, 12)
 
            data = conn.recv(1024)
            print(f"受信: {data.decode()}")
 
            conn.sendall(b"ACK: " + data)
            conn.close()
    finally:
        server.close()
        os.unlink(SOCKET_PATH)
 
# クライアント
def unix_client(message):
    client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    client.connect(SOCKET_PATH)
 
    client.sendall(message.encode())
    response = client.recv(1024)
    print(f"応答: {response.decode()}")
 
    client.close()

# I/O多重化を使った高性能サーバー（select/epoll の例）
import selectors
import socket
import types
 
# Linux: epoll, macOS: kqueue を自動選択
sel = selectors.DefaultSelector()
 
def accept_connection(sock):
    conn, addr = sock.accept()
    print(f"接続受付: {addr}")
    conn.setblocking(False)
    data = types.SimpleNamespace(addr=addr, inb=b"", outb=b"")
    events = selectors.EVENT_READ | selectors.EVENT_WRITE
    sel.register(conn, events, data=data)
 
def service_connection(key, mask):
    sock = key.fileobj
    data = key.data
 
    if mask & selectors.EVENT_READ:
        recv_data = sock.recv(1024)
        if recv_data:
            data.outb += recv_data  # エコーバック
        else:
            print(f"切断: {data.addr}")
            sel.unregister(sock)
            sock.close()
            return
 
    if mask & selectors.EVENT_WRITE:
        if data.outb:
            sent = sock.send(data.outb)
            data.outb = data.outb[sent:]
 
def run_server(host='0.0.0.0', port=12345):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind((host, port))
    sock.listen(100)
    sock.setblocking(False)
    sel.register(sock, selectors.EVENT_READ, data=None)
 
    print(f"サーバー起動: {host}:{port}")
    try:
        while True:
            events = sel.select(timeout=None)
            for key, mask in events:
                if key.data is None:
                    accept_connection(key.fileobj)
                else:
                    service_connection(key, mask)
    except KeyboardInterrupt:
        print("終了")
    finally:
        sel.close()
 
if __name__ == "__main__":
    run_server()

// POSIXメッセージキューの例
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <errno.h>
 
#define QUEUE_NAME "/my_task_queue"
#define MAX_MSG_SIZE 256
#define MAX_MSGS 10
 
// プロデューサー
void producer() {
    struct mq_attr attr = {
        .mq_flags = 0,
        .mq_maxmsg = MAX_MSGS,
        .mq_msgsize = MAX_MSG_SIZE,
        .mq_curmsgs = 0
    };
 
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_WRONLY, 0666, &attr);
    if (mq == (mqd_t)-1) {
        perror("mq_open");
        exit(1);
    }
 
    // 優先度付きメッセージの送信
    mq_send(mq, "高優先度タスク", strlen("高優先度タスク"), 10);  // 優先度10
    mq_send(mq, "低優先度タスク", strlen("低優先度タスク"), 1);   // 優先度1
    mq_send(mq, "中優先度タスク", strlen("中優先度タスク"), 5);   // 優先度5
 
    mq_close(mq);
}
 
// コンシューマー
void consumer() {
    mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY);
    char buffer[MAX_MSG_SIZE + 1];
    unsigned int priority;
 
    // 優先度の高い順に受信される
    while (1) {
        ssize_t bytes = mq_receive(mq, buffer, MAX_MSG_SIZE + 1, &priority);
        if (bytes == -1) {
            if (errno == EAGAIN) break;
            perror("mq_receive");
            break;
        }
        buffer[bytes] = '\0';
        printf("受信(優先度%u): %s\n", priority, buffer);
    }
    // 出力順: 高優先度タスク(10) → 中優先度タスク(5) → 低優先度タスク(1)
 
    mq_close(mq);
    mq_unlink(QUEUE_NAME);
}

# Pythonでのファイルロック（排他制御）の例
import fcntl
import os
import time
 
class FileLock:
    """ファイルベースのプロセス間排他制御"""
 
    def __init__(self, lockfile):
        self.lockfile = lockfile
        self.fd = None
 
    def acquire(self, timeout=10):
        self.fd = open(self.lockfile, 'w')
        start = time.time()
        while True:
            try:
                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
                self.fd.write(str(os.getpid()))
                self.fd.flush()
                return True
            except BlockingIOError:
                if time.time() - start > timeout:
                    self.fd.close()
                    raise TimeoutError(f"ロック取得タイムアウト: {self.lockfile}")
                time.sleep(0.1)
 
    def release(self):
        if self.fd:
            fcntl.flock(self.fd, fcntl.LOCK_UN)
            self.fd.close()
            try:
                os.unlink(self.lockfile)
            except OSError:
                pass
 
    def __enter__(self):
        self.acquire()
        return self
 
    def __exit__(self, *args):
        self.release()
 
# 使用例
with FileLock("/tmp/my_app.lock"):
    print("排他ロック取得。クリティカルセクション実行中...")
    time.sleep(5)
    print("完了")

# 以下のパイプラインの各段階の出力を確認せよ
ps aux | awk '{print $1}' | sort | uniq -c | sort -rn | head -5
 
# 名前付きパイプを使って2つのターミナル間で通信せよ
# ターミナル1:
mkfifo /tmp/chat
while true; do
    if read line < /tmp/chat; then
        echo "受信: $line"
    fi
done
 
# ターミナル2:
echo "Hello from terminal 2" > /tmp/chat
echo "Second message" > /tmp/chat

import signal
import sys
import os
import time
 
def handler(signum, frame):
    sig_name = signal.Signals(signum).name
    print(f"\nシグナル {sig_name}({signum}) を受信。終了処理中...")
    # クリーンアップ処理
    print("一時ファイルの削除...")
    print("接続のクローズ...")
    sys.exit(0)
 
def reload_handler(signum, frame):
    print(f"\n設定再読み込み（SIGHUP受信）")
 
signal.signal(signal.SIGTERM, handler)
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGHUP, reload_handler)
 
print(f"PID: {os.getpid()}")
print("Ctrl+C, kill -TERM, kill -HUP で操作してください")
 
while True:
    print(".", end="", flush=True)
    time.sleep(1)

# Python 3.8+ の multiprocessing.shared_memory を使った例
from multiprocessing import shared_memory, Process
import numpy as np
import time
 
def producer(shm_name):
    """共有メモリにデータを書き込むプロセス"""
    shm = shared_memory.SharedMemory(name=shm_name)
    arr = np.ndarray((10,), dtype=np.int64, buffer=shm.buf)
 
    for i in range(100):
        arr[i % 10] = i
        time.sleep(0.01)
 
    shm.close()
 
def consumer(shm_name):
    """共有メモリからデータを読み取るプロセス"""
    time.sleep(0.1)  # プロデューサーの開始を待つ
    shm = shared_memory.SharedMemory(name=shm_name)
    arr = np.ndarray((10,), dtype=np.int64, buffer=shm.buf)
 
    for _ in range(50):
        print(f"Current values: {arr.tolist()}")
        time.sleep(0.02)
 
    shm.close()
 
if __name__ == "__main__":
    # 共有メモリの作成
    shm = shared_memory.SharedMemory(create=True, size=80)  # 10 * 8bytes
 
    p1 = Process(target=producer, args=(shm.name,))
    p2 = Process(target=consumer, args=(shm.name,))
 
    p1.start()
    p2.start()
 
    p1.join()
    p2.join()
 
    shm.close()
    shm.unlink()

# サーバー（マルチクライアント対応）
import socket
import selectors
import os
 
SOCKET_PATH = "/tmp/chat_server.sock"
sel = selectors.DefaultSelector()
clients = {}
 
def accept(sock):
    conn, _ = sock.accept()
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, data="client")
    clients[conn] = f"User{len(clients)+1}"
    broadcast(f"[{clients[conn]}が参加しました]", exclude=conn)
 
def broadcast(message, exclude=None):
    for client in list(clients.keys()):
        if client != exclude:
            try:
                client.sendall(message.encode() + b"\n")
            except (BrokenPipeError, ConnectionResetError):
                disconnect(client)
 
def disconnect(conn):
    name = clients.pop(conn, "Unknown")
    sel.unregister(conn)
    conn.close()
    broadcast(f"[{name}が退出しました]")
 
def handle_client(conn):
    try:
        data = conn.recv(1024)
        if data:
            name = clients.get(conn, "Unknown")
            broadcast(f"{name}: {data.decode().strip()}", exclude=conn)
        else:
            disconnect(conn)
    except ConnectionResetError:
        disconnect(conn)
 
if os.path.exists(SOCKET_PATH):
    os.unlink(SOCKET_PATH)
 
server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
server.bind(SOCKET_PATH)
server.listen(10)
server.setblocking(False)
sel.register(server, selectors.EVENT_READ, data="server")
os.chmod(SOCKET_PATH, 0o666)
 
print(f"チャットサーバー起動: {SOCKET_PATH}")
while True:
    events = sel.select(timeout=None)
    for key, mask in events:
        if key.data == "server":
            accept(key.fileobj)
        else:
            handle_client(key.fileobj)