Jingtianer

2023-07-18发表2023-07-19更新linux11 分钟读完 (大约1609个字)

36.1

编写一个程序使用getrusage0 RUSAGE CHILDREN标记获取wait调用所等待的
子进程相关的信息。(让程序创建一个子进程并使子进程消耗一些 CPU 时间，接着
让父进程在调用wait0前后都调用getrusage0。

//
// Created by root on 7/18/23.
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/times.h>
#include <unistd.h>
#include <limits.h>
#include <sys/resource.h>

#define CHECK(x) \
        do {     \
            if(!(x)) { \
                fprintf(stderr, "%s:%d\nerror: %s\n", __FILE__, __LINE__,strerror(errno)); \
                exit(0); \
            }    \
        } while(0)



#define rcputime(rusage, xtime) rusage.xtime.tv_sec + rusage.xtime.tv_usec/1000000.0
int main(int argc, char **argv) {
    long tic = sysconf(_SC_CLK_TCK);
    long tottm = 0;
    for(int i = 1; i < argc; i++) {
        char *end = NULL;
        long sec = strtol(argv[i], &end, 10);
        tottm += sec;
        CHECK(end != argv[i] && errno == 0);
        if(!fork()) {
            struct tms tms, start;
            CHECK(times(&start) != (clock_t) -1);
            CHECK(times(&tms) != (clock_t) -1);
            for(; (tms.tms_utime + tms.tms_stime)/tic - (start.tms_utime + start.tms_stime)/tic <= sec;) {
                CHECK(times(&tms) != (clock_t) -1);
            }
            exit(0);
        }
    }
    printf("total time:%ld\n", tottm);
    struct rusage rusage;
    CHECK(getrusage(RUSAGE_CHILDREN, &rusage) != -1);
    printf("child use:\n\tcpu time:%.2lfs (user)\n\tcpu time:%.2lfs (system)\ntotal:%.2lfs\n", rcputime(rusage, ru_utime), rcputime(rusage, ru_stime), rcputime(rusage, ru_utime) + rcputime(rusage, ru_stime));
    for(;;)
        if(waitpid(-1, NULL, 0) == -1 && errno == 10) break;
    CHECK(getrusage(RUSAGE_CHILDREN, &rusage) != -1);
    printf(""
            "child use:\n"
            "\tcpu time:\n"
            "\t\tcpu time:%.2lfs (user)\n"
            "\t\tcpu time:%.2lfs (system)\n"
            "\ttotal:%.2lfs\n"
            "\tMax resident set:%ldKB\n"
           "\tIntegral shared text mem:%ldkB/s\n"
           "\tIntegral shared data mem:%ldkB/s\n"
           "\tIntegral shared stack mem:%ldkB/s\n"
           "\tsoft page fault:%ld\n"
           "\thard page fault:%ld\n"
           "\tswaps out of physical mem:%ld\n"
           "\tfile input block:%ld\n"
           "\tfile output block:%ld\n"
           "\tIPC msg send:%ld\n"
           "\tIPC msg recv:%ld\n"
           "\tsignal recv:%ld\n"
           "\tvoluntary context switch:%ld\n"
           "\tinvoluntary context switch:%ld\n",
           rcputime(rusage, ru_utime),
           rcputime(rusage, ru_stime),
           rcputime(rusage, ru_utime) + rcputime(rusage, ru_stime),
           rusage.ru_maxrss,
           rusage.ru_ixrss,
           rusage.ru_idrss,
           rusage.ru_isrss,
           rusage.ru_minflt,
           rusage.ru_majflt,
           rusage.ru_nswap,
           rusage.ru_inblock,
           rusage.ru_oublock,
           rusage.ru_msgsnd,
           rusage.ru_msgrcv,
           rusage.ru_nsignals,
           rusage.ru_nvcsw,
           rusage.ru_nivcsw);
}

36.2

编写一个程序来执行一个命令，接着显示其当前的资源使用。这个程序与 time(1)
命令的功能类似，因此可以像下面这样使用这个程序:

1	$ ./rusage command arg...

2023-07-17发表2023-07-19更新linux12 分钟读完 (大约1805个字)

cha35.进程优先级和调度

读书笔记

nice

nice值形象的说是一个进程的友好（nice）程度，越nice（nice值数值越大的）的进程越礼让，多个任务争用cpu的时候越礼让。（本书中高nice值表示nice值数值更低，更不nice

取值范围为(-20(不友好，高优先级)-19(友好，低优先级))
fork、exec时继承nice值

RLIMIT_NICE

资源限制，特权进程最高可以将nice值提升到20-RLIMIT_NICE

2023-07-10发表2023-07-14更新linux12 分钟读完 (大约1752个字)

cha34.进程组、会话和作业控制

读书笔记

34.1

假设一个父进程执行了下面的步骤。
这个应用程序设计可能会碰到什么问题?考虑 shell 管道。
如何避免此类问题的发生?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

void handler(int sig){
    printf("%d, received %d(%s)\n", getpid(), sig, strsignal(sig));
}

int main() {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    signal(SIGUSR1, handler);
    for(int i = 0; i < 10; i++) {
        pid_t pid;
        if((pid = fork()) == 0) {
            pause();
            return 0;
        } else {
            printf("child-%d: %d\n", i, pid);
        }
    }
    signal(SIGUSR1, SIG_IGN);
    killpg(getpgrp(), SIGUSR1);
    waitpid(-1, NULL, 0);
}

假设不发送SIGUSER时
- 当不使管道时，可以看到有小于等于10个子进程显示收到SIGUSER1
- 如果使用管道，会发现child-%d: %d被重复输出了多次，这是由于stdout被重定向后变成了全缓冲，fork的子进程退出后fflush()时会将fork前未flush的数据打印出来。
假设执行该命令./practice34.1 | cat，输出会是User defined signal 1，即cat与程序同属一个进程组，cat也会收到该信号，导致无法正常执行（非预期内）

避免

2023-07-01发表2023-07-03更新linux5 分钟读完 (大约718个字)

cha33.线程：更多细节

33.1

编写程序以便证明:作为函数sigpending()的返回值，同一个进程中的的不同线程可以拥有不同的 pending信号。可以使用函数pthread_kill(分别发送不同的信号给阻塞这些信号的两个不同的线程,接着调用sigpending()方法并显示这些pending信号的信息。(可能会发现程序清单20-4中函数的作用。)

//
// Created by root on 7/2/23.
//
#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#define CHECK(x) do { if(!(x)) { fprintf(stderr, "ERROR: %s\nfile=%s, line=%d\n", strerror(errno), __FILE__, __LINE__); exit(1); } } while(0)
#define THREAD_CNT 5
pthread_mutex_t sig_mutex;
pthread_cond_t sig_cond;
int thread_ready_count;

void handler(int sig, siginfo_t *info, void *context) {
    printf("recv sig = %d: %s, from = %d\n", sig, strsignal(sig), info->si_value.sival_int);
}

pthread_t tid2pthread[THREAD_CNT];

int tid2sig(int tid) {
    return SIGRTMAX - 1 - tid;
}

void *fun_thread(void *arg) {
    int tid  = *(int *)arg;
    free(arg);
    sigset_t set;
    CHECK(sigemptyset(&set) == 0);
    CHECK(sigaddset(&set, tid2sig(tid)) == 0);
    CHECK(pthread_sigmask(SIG_SETMASK, &set, NULL) == 0);
    CHECK(sigaction(tid2sig(tid), &(struct sigaction) {
        .sa_sigaction   =handler,
        .sa_flags       = SA_SIGINFO,
        .sa_mask        = 0
    }, NULL) == 0);
    printf("Thread-%d, sigaction %d\n", tid, tid2sig(tid));
    CHECK(pthread_mutex_lock(&sig_mutex) == 0);
    thread_ready_count++;
    tid2pthread[tid] = pthread_self();
    CHECK(pthread_mutex_unlock(&sig_mutex) == 0);
    CHECK(pthread_cond_broadcast(&sig_cond) == 0);

    CHECK(pthread_mutex_lock(&sig_mutex) == 0);
    while(thread_ready_count < THREAD_CNT){
        CHECK(pthread_cond_wait(&sig_cond, &sig_mutex) == 0);
    }
    CHECK(pthread_mutex_unlock(&sig_mutex) == 0);
    int sig = tid2sig((tid + 1) % THREAD_CNT);
    printf("Thread-%d send %d(%s) to %d\n", tid, sig, strsignal(sig), (tid + 1) % THREAD_CNT);
    CHECK(pthread_sigqueue(tid2pthread[(tid + 1) % THREAD_CNT], sig, (union sigval) {
        .sival_int=tid
    }) == 0);
    do {
        printf("Thread-%d sig not pending %d\n", tid, tid2sig(tid));
        sleep(1);
        CHECK(sigemptyset(&set) == 0);
        CHECK(sigpending(&set) == 0);
    } while(sigismember(&set, tid2sig(tid)) == 0);
    printf("Thread-%d sig pending %d\n", tid, tid2sig(tid));
    CHECK(sigemptyset(&set) == 0);
    CHECK(pthread_sigmask(SIG_SETMASK, &set, NULL) == 0);
    CHECK(sigpending(&set) == 0);
    sig = -1;
    while(sig != tid2sig(tid)) CHECK(sigwait(&set, &sig) == 0);
    printf("Thread-%d exit\n", tid);
    return NULL;
}

int main(int argc, char *argv[]) {
    CHECK(pthread_mutex_init(&sig_mutex, NULL) == 0);
    CHECK(pthread_cond_init(&sig_cond, NULL) == 0);
    thread_ready_count = 0;
    for(int i = 0; i < THREAD_CNT; i++) {
        pthread_t thread;
        int *data = malloc(sizeof(int));
        *data = i;
        CHECK(pthread_create(&thread, NULL, fun_thread, data) == 0);
    }
    pthread_exit(NULL);
}

33.2

假设一个线程使用fork()创建了一个子进程。当子进程终止时，可以保证由此产生的SIGCHLD信号一定会发送给调用fork()的线程吗(可以用进程中的其他线程做对比)?

//
// Created by root on 7/2/23.
//
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/wait.h>

#define CHECK(x) do { if(!(x)) { fprintf(stderr, "ERROR: %s\nfile=%s, line=%d\n", strerror(errno), __FILE__, __LINE__); exit(1); } } while(0)

sigset_t set;

void handler(int sig, siginfo_t *info, void *context) {
    printf("recv sig = %d: %s, my tid is %ld\n", sig, strsignal(sig), pthread_self());
}

void *fn(void *arg) {
    CHECK(sigaction(SIGCHLD, &(struct sigaction) {
            .sa_mask = 0,
            .sa_flags = SA_SIGINFO,
            .sa_sigaction=handler
    }, NULL) == 0);
    if(*(int *)arg) {
        printf("I am %ld, I fork\n", pthread_self());
        if(!fork()) {
            exit(0);
        }
//        wait(NULL);
    } else {
        printf("I am %ld, I sleep\n", pthread_self());
        sleep(10);
    }
    free(arg);
    return NULL;
}

int main() {
    CHECK(sigemptyset(&set) == 0);
    CHECK(sigaddset(&set, SIGCHLD) == 0);
    CHECK(sigaction(SIGCHLD, &(struct sigaction) {
        .sa_mask = 0,
        .sa_flags = SA_SIGINFO,
        .sa_sigaction=handler
    }, NULL) == 0);
    pthread_t tid;
    int ok = 0;
    CHECK(pthread_create(&tid, NULL, fn, memcpy(malloc(sizeof(int)), &ok, sizeof(int))) == 0);
    ok = 1;
    CHECK(pthread_create(&tid, NULL, fn, memcpy(malloc(sizeof(int)), &ok, sizeof(int))) == 0);
    pthread_exit(NULL);
}

2023-06-29发表2023-06-30更新linux3 分钟读完 (大约425个字)

cha32.线程取消

读书笔记

带参宏

从作用域的角度上看，带参宏和函数的区别：

函数有新的函数栈，而带参宏没有，因而带参宏在不同作用域调用时，会受到作用域的影响。如在宏A中的定义的变量，也会影响后续。
如果一对作用相反的带参宏，如本节的pthread_cleanup_push和pthread_cleanup_pop，很多实现都是使用带参宏，那么这两个宏调用时必须属于同一个代码块

?，保证push的作用域包含pop不就好了吗

线程取消

线程取消状态可设置为启用和禁用。

2023-06-29发表2023-06-29更新linux4 分钟读完 (大约538个字)

cha31.线程安全和每线程存储

读书笔记

pthread提供了一种所有线程只执行一次（用于所有线程只初始化一次）的方法pthread_once(pthread_once_t*, void (*)(void));
pthread提供了每线程存储，即每个线程有独立与其他线程的存储，使用k-v存储
- int pthread_key_create(pthread_key_t *, void (*)(void *));每个线程都存储一份，第一个参数为一个全局变量的指针，第二个参数为线程终止时自动调用的析构函数
- int pthread_setspecific(pthread_key_t, const void *)指定key所对应的内存区域，进程终止时会将第二个参数送入析构函数
- void * pthread_getspecific(pthread_key_t)获取key所对应的内存区域

31.1

实现pthread_once

//
// Created by root on 6/29/23.
//

#include <pthread.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>

void init() {
    printf("init\n");
}
typedef struct {
    pthread_mutex_t mutex;
    bool call;
} _pthread_once_t;
_pthread_once_t once = {
        .mutex=PTHREAD_MUTEX_DEFAULT,
        .call=false
};
int _pthread_once(_pthread_once_t *once_ctrl, void (*init)(void)) {
    bool ok;
    if(pthread_mutex_lock(&once_ctrl->mutex) == 0) {
        ok = !once_ctrl->call;
        once_ctrl->call = true;
        pthread_mutex_unlock(&once_ctrl->mutex);
    } else {
        return -1;
    }
    if(ok) {
        init();
    }
    return 0;
}

void *fun(void *arg) {
    printf("Thread-%d start\n", *(int*)arg);
    if(_pthread_once(&once, init) == 0){
        printf("Thread-%d _pthread_once Success\n", *(int*)arg);
    }
    free(arg);
    return NULL;
}

int main() {
    pthread_t t;
    for(int i = 1; i <= 100; i++)
        pthread_create(&t, NULL, fun, memcpy(malloc(sizeof(int)), &i, sizeof(int)));
    pthread_exit(NULL);
}

31.2

2023-06-29发表2023-06-29更新linux15 分钟读完 (大约2201个字)

cha30.线程：线程同步

读书笔记

条件变量

一般搭配一个条件和一个互斥量使用

经典的使用方式如下

对于需要在某某条件下运行的线程，先对mutex加锁，以读取condition
- 若满足，则在预期状态下执行后续操作，结束后对mutex解锁
- 若不满足，则pthread_cond_wait
  - 此时该函数会先解锁mutex（允许其他进程获取mutex以修改状态）
  - 陷入阻塞，直到其他线程调用pthread_cond_signal或pthread_cond_broadcast唤醒
  - 唤醒后，获取mutex锁，以检查条件是否满足，满足则执行后续，不满足继续调用wait阻塞（故此处需要用while）
对于可以改变某某条件的线程
- 获取mutex
- 改变condition
- signal/broadcast
- unlock(unlock与上一步顺序可调换)

// one thread
pthread_mutex_lock(&mutex);
while(!condition)
    pthread_cond_wait(&cond, &mutex);
/* condition matched, execute task */
pthread_mutex_unlock(&mutex);

// other thread
pthread_mutex_lock(&mutex);
condition = xxxx; // change condition
pthread_cond_signal(&cond); // or pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mutex); // 以上两行顺序任意，

2023-06-27发表2023-06-27更新linux3 分钟读完 (大约413个字)

cha29.线程：介绍

29.1

若一线程执行了如下代码,可能会产生什么结果?
pthread_join(pthread_self()，NULL);
在 Linux上编写一个程序，观察一下实际会发生什么情况。假设代码中有一变量 tid,其中包含了某个线程ID，在自身发起pthread_join(tid, NULL)调用时，要避免造成与上述语句相同的后果，该线程应采取何种措施?

#define CHECK(x) do { \
                        if(!(x)) { \
                            fwritef(STDERR_FILENO, "error: %s\n", strerror(errno));     \
                            pthread_exit(NULL); \
                        }      \
                    } while(0)
void *thread1_fun(void * args) {
    sleep(1);
    return NULL;
}

void *thread_fun(void * args) {
    void *ret;
    printf("thread: before,join-pthread_self()\n");
    CHECK(pthread_join(pthread_self(), &ret) == 0);
    printf("thread: after,join-pthread_self()\n");
    return NULL;
}

int main() {
    pthread_t thread;
    CHECK(pthread_create(&thread, NULL, thread_fun, NULL) == 0);
    CHECK(pthread_detach(thread) == 0);
    printf("main: pthread_created.\n");
    sleep(10);
    return 0;
}

结果

pthread_join返回值非0，出现错误，errno表示SUCCESS

为啥是success呢，errno不是一个线程一份吗，还是这个函数不算系统调用？？可能是他调用了waitpid，但是出错位置不在waitpid

2023-06-20发表2023-06-21更新linux8 分钟读完 (大约1160个字)

cha27.进程执行

exec()

带e的可以指定环境变量，否则继承
带p的允许只提供文件名，允许提供不带"/"的路径，在path中寻找
- 若无env PATH默认为.:/usr/bin/:/bin
- 从左往右搜索，直到找到为止
带l的用不定长参数（参数列表），以NULL结尾
- execle在NULL后面接envp数组

exec执行脚本

当exec第一个参数文件以"#!"开始，则会读取该行进行解析

1	#!<interpreter-path> [arg] <script> <script-args...>

如

2023-06-19发表2023-06-20更新linux5 分钟读完 (大约687个字)

cha26.监控子进程

孤儿与僵尸

孤儿：子进程结束前父进程未wait结束的进程。其父进程会变成1由init接管进行wait
僵尸：父进程未结束，子进程已经结束，且父进程未执行wait。系统保留僵尸的进程表记录，以备未来父进程需要wait获取其结束状态
- 无法被kill，只能kill其父进程

1

编写一程序以验证当一子进程的父进程终止时，调用getppid()将返回1（进程 init的进程ID)。

无聊，不弄

2

36.1

36.2

读书笔记

nice

RLIMIT_NICE

读书笔记

34.1

避免

33.1

33.2

读书笔记

带参宏

线程取消

读书笔记

31.1

31.2

读书笔记

条件变量

29.1

结果

exec()

exec执行脚本

孤儿与僵尸

1

2

链接

分类

最新文章

归档

标签