【Linux】多线程(自旋锁、读写锁)-linux运维-PHP中文网

【Linux】多线程(自旋锁、读写锁)

蓮花仙者

发布： 2025-06-19 16:22:15

原创

813人浏览过

自旋锁概述

自旋锁是一种多线程同步机制，旨在保护共享资源免受并发访问的影响。在多个线程尝试获取锁时，它们会持续在循环中自旋（即不断检查锁是否可用），而不是立即进入休眠状态等待锁的释放。这种方法减少了线程切换的开销，适合于短时间内锁的竞争情况。然而，不恰当的使用可能会导致cpu资源的浪费。

自旋锁的原理

自旋锁通常使用一个共享的标志位（例如一个布尔值）来表示锁的状态。当标志位为true时，表示锁已被某个线程占用；当标志位为false时，表示锁可用。当一个线程尝试获取自旋锁时，它会不断检查标志位：

如果标志位为false，表示锁可用，线程将设置标志位为true，表示自己占用了锁，并进入临界区。
如果标志位为true（即锁已被其他线程占用），线程会在一个循环中持续自旋等待，直到锁被释放。

自旋锁的优点与缺点

优点：

低延迟：自旋锁适用于短时间内的锁竞争情况，因为它不会让线程进入休眠状态，从而避免了线程切换的开销，提高了锁操作的效率。
减少系统调度开销：等待锁的线程不会被阻塞，不需要上下文切换，从而减少了系统调度的开销。

缺点：

CPU资源浪费：如果锁的持有时间较长，等待获取锁的线程会一直循环等待，导致CPU资源的浪费。
可能引起活锁：当多个线程同时等待一个锁时，如果没有适当的退避策略，可能会导致所有线程都在不断检查锁状态而无法进入临界区，形成活锁。

自旋锁的使用场景

短暂等待的情况：适用于锁被占用时间非常短的场景，如多线程对共享数据进行简单的读写操作。
多线程锁使用：通常用于系统底层，同步多个CPU对共享资源的访问。

Linux提供的自旋锁系统调用

int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);

登录后复制

pshared有两个选项，PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。private选项表示自旋锁只能在同一进程内的多个线程内使用，pshared表示可以在多个不同的进程内使用同一个自旋锁。

自旋锁的注意事项

在使用自旋锁时，需要确保锁被释放的时间尽可能短，以避免CPU资源的浪费。
在多CPU环境下，自旋锁可能不如其他锁机制高效，因为它可能导致线程在不同的CPU上自旋等待。

自旋锁的结论

自旋锁是一种适用于短时间内锁竞争情况的同步机制，它通过减少线程切换的开销来提高锁操作的效率。然而，它也存在CPU资源浪费和可能引起活锁等缺点。在使用自旋锁时，需要根据具体的应用场景进行选择，并确保锁被释放的时间尽可能短。

样例代码

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

int ticket = 1000;
pthread_spinlock_t lock;

void *route(void *arg) {
    char *id = (char *)arg;
    while (1) {
        pthread_spin_lock(&lock);
        if (ticket > 0) {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
            pthread_spin_unlock(&lock);
        } else {
            pthread_spin_unlock(&lock);
            break;
        }
    }
    return NULL;
}

int main(void) {
    pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, route, (void *)"thread 1");
    pthread_create(&t2, NULL, route, (void *)"thread 2");
    pthread_create(&t3, NULL, route, (void *)"thread 3");
    pthread_create(&t4, NULL, route, (void *)"thread 4");
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_spin_destroy(&lock);
    return 0;
}

登录后复制

读写锁概述

在编写多线程程序时，常见一种情况是公共数据的修改机会较少，而读取的机会则相对较多。通常，读取过程伴随着查找操作，耗时较长。如果对这种代码段加锁，会极大地降低程序的效率。针对这种多读少写的情况，有一种专门的处理方法，即读写锁。

【Linux】多线程(自旋锁、读写锁)

pthread库为我们提供了读写锁。

读写锁的初始化和销毁

【Linux】多线程(自旋锁、读写锁)

读写锁的加锁和解锁

【Linux】多线程(自旋锁、读写锁)

样例代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <cstdlib>
#include <ctime>

// 共享资源
int shared_data = 0;

// 读写锁
pthread_rwlock_t rwlock;

// 读者线程函数
void *Reader(void *arg) {
    int number = *(int *)arg;
    while (true) {
        pthread_rwlock_rdlock(&rwlock); // 读者加锁
        std::cout << "Reader " << number << " is reading. Shared data: " << shared_data << std::endl;
        pthread_rwlock_unlock(&rwlock); // 读者解锁
        sleep(1); // 模拟读取时间
    }
    return NULL;
}

// 写者线程函数
void *Writer(void *arg) {
    int number = *(int *)arg;
    while (true) {
        pthread_rwlock_wrlock(&rwlock); // 写者加锁
        shared_data++;
        std::cout << "Writer " << number << " is writing. Shared data: " << shared_data << std::endl;
        pthread_rwlock_unlock(&rwlock); // 写者解锁
        sleep(1); // 模拟写入时间
    }
    return NULL;
}

int main() {
    pthread_rwlock_init(&rwlock, NULL);

    std::vector<pthread_t> threads;
    int num_readers = 5;
    int num_writers = 2;

    for (int i = 0; i < num_readers; i++) {
        int *arg = new int(i);
        pthread_t thread;
        pthread_create(&thread, NULL, Reader, arg);
        threads.push_back(thread);
    }

    for (int i = 0; i < num_writers; i++) {
        int *arg = new int(i);
        pthread_t thread;
        pthread_create(&thread, NULL, Writer, arg);
        threads.push_back(thread);
    }

    for (auto thread : threads) {
        pthread_join(thread, NULL);
    }

    pthread_rwlock_destroy(&rwlock);
    return 0;
}

登录后复制

读者优先策略

在这种策略中，系统会尽可能多地允许多个读者同时访问资源（比如共享文件或数据），而不会优先考虑写者。这意味着当有读者正在读取时，新到达的读者会立即被允许进入读取区，而写者则会被阻塞，直到所有读者都离开读取区。读者优先策略可能会导致写者饥饿（即写者长时间无法获得写入权限），特别是当读者频繁到达时。

写者优先策略

在这种策略中，系统会优先考虑写者。当写者请求写入权限时，系统会尽快地让写者进入写入区，即使此时有读者正在读取。这通常意味着一旦有写者到达，所有后续的读者都会被阻塞，直到写者完成写入并离开写入区。写者优先策略可以减少写者等待的时间，但可能会导致读者饥饿（即读者长时间无法获得读取权限），特别是当写者频繁到达时。

以上就是【Linux】多线程(自旋锁、读写锁)的详细内容，更多请关注php中文网其它相关文章！