Linux应用层

线程管理

线程控制

线程创建

通过pthread_create函数创建线程，线程可以并发执行任务。示例中创建了两个线程，一个用于读取控制台输入，另一个用于将数据输出到控制台。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#define BUF_LEN 1024

char *buf;

void *input_thread(void *argv){
    int i = 0;
    while(1){
        char c = fgetc(stdin);
        if(c && c != '\n'){
            buf[i++] = c;
        }
        if(i >= BUF_LEN){
            i = 0;
        }
    }
}

void *output_thread(void *argv){
    int i = 0;
    while(1){
        if(buf[i]){
            fputc(buf[i], stdout);
            fputc('\n', stdout);
            buf[i++] = 0;
            if(i >= BUF_LEN){
                i = 0;
            }
        }else{
            sleep(1);
        }
    }
}

// 创建两个线程 一个读取控制台数据 一个将数据写出控制台



int main(int argc, char const *argv[])
{
    pthread_t pid_input;
    pthread_t pid_output;

    buf = (char *)malloc(sizeof(char) * BUF_LEN);

    // 创建读线程
    pthread_create(&pid_input, NULL, input_thread, NULL);

    //创建写线程
    pthread_create(&pid_output, NULL, output_thread, NULL);

    //主线线程等待子线程结束
    pthread_join(pid_input, NULL);
    pthread_join(pid_output, NULL);

    free(buf);

    return 0;
}

线程终止

线程可以通过pthread_exit或返回函数值自然终止，也可以通过pthread_cancel强制终止。pthread_setcanceltype可以设置取消类型为异步或延迟。

detach不挂起终止

使用pthread_detach标记线程为分离状态，线程结束后自动回收资源，主线程无需等待。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

void *task(void *arg){
    printf("thread started\n");
    sleep(2);
    printf("thread finished\n");
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    // 使用detach标记 等线程完成后回收相关资源
    pthread_detach(tid);

    // 主线程运行完成比创建的线程慢
    printf("main thread continues\n");
    sleep(3); //因为主线程不会等待 如果父线程先结束会强制杀死子进程
    printf("main thread ending");
    return 0;
}


cancel的延迟取消

通过pthread_cancel发送取消请求，线程在遇到取消点（如sleep或pthread_testcancel）时才会终止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

void *task(void *arg){
    printf("thread started\n");
    //默认取消类型是延迟
    printf("working...");
    sleep(1); //sleep()会检测是否有取消请求标记
    //人为调用取消点函数
    pthread_testcancel();
    printf("thread finished\n");
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);

    // 取消子线程
    if (pthread_cancel(tid) != 0)
    {
        perror("pthread_cancel");
    }
    void *res;
    // pthread_cancel只是发出一个停止命令
    pthread_join(tid, &res);
    if(res == PTHREAD_CANCELED){
        printf("线程被取消\n");
    }else{
        printf("线程没有被取消 exit code %ld\n", (long)res);
    }

    return 0;
}


cancel的异步取消和禁用取消

pthread_setcancelstate可以禁用或启用线程的取消响应，pthread_setcanceltype设置取消类型为异步。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

void *task(void *arg){
    //printf("thread started, thread id: %lu\n", pthread_self());
    int oldstate;

    //fflush(stdout); // 确保输出立即刷新
    //printf("cancel state disabled, old state: %d\n", oldstate);
    // 禁用取消响应
    //pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);

    printf("working...\n");
    fflush(stdout); // 确保输出立即刷新

    sleep(1); // sleep() 会检测是否有取消请求标记

    printf("cancel state check before re-enable, old state: %d\n", oldstate);
    fflush(stdout); // 确保输出立即刷新

    // 恢复取消状态
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
    printf("cancel state enabled, restored old state: %d\n", oldstate);
    fflush(stdout); // 确保输出立即刷新

    printf("thread finished\n");
    fflush(stdout); // 确保输出立即刷新

    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    pthread_create(&tid, NULL, task, NULL);
    // 取消子线程
    if (pthread_cancel(tid) != 0)
    {
        perror("pthread_cancel");
    }
    void *res;
    // pthread_cancel 只是发出一个停止命令
    pthread_join(tid, &res);
    if(res == PTHREAD_CANCELED){
        printf("线程被取消\n");
    }else{
        printf("线程没有被取消 exit code %ld\n", (long)res);
    }

    return 0;
}

线程同步

竞态条件与互斥锁

多个线程同时访问共享资源可能导致竞态条件。使用互斥锁（pthread_mutex_lock和pthread_mutex_unlock）确保同一时间只有一个线程访问共享资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

#define THREAD_COUNT 30000

// 初始化锁
static pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;

void *add_thread(void *arg){
    int *p = (int *)arg;
    // 在累加之前获取锁 保证只有一个线程进行累加
    pthread_mutex_lock(&counter_mutex);
    (*p)++;
    // 累加之后释放锁
    pthread_mutex_unlock(&counter_mutex);
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t pid[THREAD_COUNT];
    int num = 0;
    for(size_t i = 0; i < THREAD_COUNT; i++){
        //创建的线程功能是给传入的参数加一
        pthread_create(pid + i, NULL, add_thread, &num);
    }

    for (size_t i = 0; i < THREAD_COUNT; i++)
    {
        pthread_join(pid[i], NULL);
    }
    
    printf("累加结果%d\n", num);
    return 0;
}

读写锁

读写锁（pthread_rwlock）允许多个线程同时读取共享资源，但写操作需要独占访问，适合读多写少的场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include<unistd.h>
#include<stdio.h>
#include<pthread.h>

//static pthread_rwlock_t rwlock = __PTHREAD_RWLOCK_INITIALIZER;
pthread_rwlock_t rwlock;
int shared_date = 0;

void *lock_write(void *arg){
    
    pthread_rwlock_wrlock(&rwlock);
    int tmp = shared_date + 1;
    sleep(1);
    shared_date = tmp;
    pthread_rwlock_unlock(&rwlock);
    printf("但前是%s, shared_date为%d\n", (char *)arg, shared_date);
}

void *lock_read(void *arg){
    // 读写锁中的度是可以由多个线程统一读取的
    //获取读锁
    pthread_rwlock_rdlock(&rwlock);
    printf("当前是%s,shared_date为%d\n", (char*)arg, shared_date);
    pthread_rwlock_unlock(&rwlock);
    
}

int main(int argc, char const *argv[])
{
    //动态初始化读写锁
    pthread_rwlock_init(&rwlock, NULL);

    pthread_t write1, write2, reader1, reader2, reader3, reader4, reader5, reader6;

    //创建两个写线程
    pthread_create(&write1, NULL, lock_write, "write1");
    pthread_create(&write2, NULL, lock_write, "write2");

    // 休眠等待
    sleep(3);

    pthread_create(&reader1, NULL, lock_read, "reader1");
    pthread_create(&reader2, NULL, lock_read, "reader2");
    pthread_create(&reader3, NULL, lock_read, "reader3");
    pthread_create(&reader4, NULL, lock_read, "reader4");
    pthread_create(&reader5, NULL, lock_read, "reader5");
    pthread_create(&reader6, NULL, lock_read, "reader6");

    //主线程等待创建的子线程运行完成
    pthread_join(write1, NULL);
    pthread_join(write2, NULL);
    pthread_join(reader1, NULL);
    pthread_join(reader2, NULL);
    pthread_join(reader3, NULL);
    pthread_join(reader4, NULL);
    pthread_join(reader5, NULL);
    pthread_join(reader6, NULL);


    //销毁读写锁
    pthread_rwlock_destroy(&rwlock);
    return 0;

}

读写锁的写饥饿解决

通过设置读写锁属性（pthread_rwlockattr_setkind_np）为写优先，避免写线程因大量读线程而长时间等待。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include<unistd.h>
#include<stdio.h>
#include<pthread.h>

//static pthread_rwlock_t rwlock = __PTHREAD_RWLOCK_INITIALIZER;
pthread_rwlock_t rwlock;
int shared_date = 0;

void *lock_write(void *arg){
    
    printf("我%s要获取写锁\n", (char *)arg);
    pthread_rwlock_wrlock(&rwlock);
    int tmp = shared_date + 1;
    shared_date = tmp;
    printf("当前是%s, shared_date为%d\n", (char *)arg, shared_date);
    pthread_rwlock_unlock(&rwlock);
    printf("%s释放了写\n锁", (char*)arg);
}

void *lock_read(void *arg){
    // 读写锁中的度是可以由多个线程统一读取的
    //获取读锁
    printf("我%s要获取读锁\n", (char*)arg);
    pthread_rwlock_rdlock(&rwlock);
    printf("当前是%s,shared_date为%d\n", (char*)arg, shared_date);
    sleep(1);
    pthread_rwlock_unlock(&rwlock);
    printf("%s释放了读锁\n", (char*)arg);
    
}

int main(int argc, char const *argv[])
{
    //创建读写锁属性对象
    pthread_rwlockattr_t attr;
    pthread_rwlockattr_init(&attr);
    //修改对象属性 设置写优先
    pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
    //动态初始化读写锁
    pthread_rwlock_init(&rwlock, &attr);

    pthread_t write1, write2, reader1, reader2, reader3, reader4, reader5, reader6;

    //创建两个写线程
    pthread_create(&write1, NULL, lock_write, "write1");

    pthread_create(&reader1, NULL, lock_read, "reader1");
    pthread_create(&reader2, NULL, lock_read, "reader2");
    pthread_create(&reader3, NULL, lock_read, "reader3");
    // 在线程读取的中间获取一个写锁的操作
    pthread_create(&write2, NULL, lock_write, "write2");
    pthread_create(&reader4, NULL, lock_read, "reader4");
    pthread_create(&reader5, NULL, lock_read, "reader5");
    pthread_create(&reader6, NULL, lock_read, "reader6");

    //主线程等待创建的子线程运行完成
    pthread_join(write1, NULL);
    pthread_join(write2, NULL);
    pthread_join(reader1, NULL);
    pthread_join(reader2, NULL);
    pthread_join(reader3, NULL);
    pthread_join(reader4, NULL);
    pthread_join(reader5, NULL);
    pthread_join(reader6, NULL);


    //销毁读写锁
    pthread_rwlock_destroy(&rwlock);
    return 0;

}

自旋锁

**自旋锁（Spinlock）**是一种用于多线程或多核环境下保护共享资源的同步机制。当线程尝试获取锁时，如果锁已被占用，线程会进入忙等待状态（自旋），不断检查锁是否被释放，而不是进入阻塞状态。自旋锁适用于锁持有时间较短的场景，避免线程切换的开销，但长时间自旋会浪费CPU资源。

条件变量

条件变量（pthread_cond_wait和pthread_cond_signal）用于线程间通信，允许线程在特定条件满足时唤醒其他线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>

#define BUFFER_SIZE 5
int buffer[BUFFER_SIZE];
int count = 0;

// 初始化互斥锁
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 初始化条件变量
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void * producer(void *arg){
    int item = 1;
    //获取互斥锁
    pthread_mutex_lock(&mutex);
    while(1){
        // 如果缓冲区写满 使用条件变量暂时释放当前线程
        if(count == BUFFER_SIZE){
            //唤醒消费者
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond, &mutex);
        }
        //缓冲区没有满
        buffer[count++] = item++;
        printf("白月光发送了一个幸运数字%d\n", buffer[count - 1]);

    }
    //释放
    pthread_mutex_unlock(&mutex);
}
void * consumer(void *arg){
    //获取互斥锁
    pthread_mutex_lock(&mutex);
    while(1){
        if(count == 0){
            //唤醒生产者
            pthread_cond_signal(&cond);
            //缓冲中没有消息可读
            pthread_cond_wait(&cond, &mutex);
        }
        printf("我收到白月光的幸运数字%d\n", buffer[--count]);
    }
    //释放
    pthread_mutex_unlock(&mutex);
}

int main(int argc, char const *argv[])
{
    // 创建两个线程
    pthread_t producer_thread, consumer_thread;

    pthread_create(&producer_thread, NULL, producer,NULL);
    pthread_create(&consumer_thread, NULL, consumer,NULL);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    return 0;
}

线程池

线程池是一种并发编程技术，通过预先创建一组线程并复用它们来执行任务，避免了频繁创建和销毁线程的开销。线程池的核心思想是将任务提交到任务队列中，由池中的空闲线程从队列中取出任务并执行。它适用于需要处理大量短任务的场景，能够提高程序性能、降低资源消耗，并简化线程管理。常见的线程池实现包括固定大小线程池、动态调整线程池等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include<glib.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

void task_func(gpointer data, gpointer user_data){
    int task_num = *(int *)data;
    free(data);
    printf("开始执行%d任务\n", task_num);
    sleep(task_num);
    printf("%d任务执行完成\n", task_num);
}

int main(int argc, char const *argv[])
{
    //创建线程池
    GThreadPool *pool = g_thread_pool_new(task_func, NULL, 5, TRUE, NULL);

    //向线程池中添加任务
    for(int i = 0; i < 10; i++){
        //每一个任务的编号
        int *tmp = (int*)malloc(sizeof(int));
        *tmp = i + 1;

        g_thread_pool_push(pool, tmp, NULL);
    }

    g_thread_pool_free(pool, FALSE, TRUE);
    printf("所有的任务都完成了\n");
    return 0;
}

说些什么吧！

valine