自旋锁概述
自旋锁是一种多线程同步机制，旨在保护共享资源免受并发访问的影响。在多个线程尝试获取锁时，它们会持续在循环中自旋（即不断检查锁是否可用），而不是立即进入休眠状态等待锁的释放。这种方法减少了线程切换的开销，适合于短时间内锁的竞争情况。然而，不恰当的使用可能会导致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:%dn", 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; }
读写锁概述
在编写多线程程序时，常见一种情况是公共数据的修改机会较少，而读取的机会则相对较多。通常，读取过程伴随着查找操作，耗时较长。如果对这种代码段加锁，会极大地降低程序的效率。针对这种多读少写的情况，有一种专门的处理方法，即读写锁。
pthread库为我们提供了读写锁。
读写锁的初始化和销毁
读写锁的加锁和解锁
样例代码
#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; }
读者优先策略
在这种策略中，系统会尽可能多地允许多个读者同时访问资源（比如共享文件或数据），而不会优先考虑写者。这意味着当有读者正在读取时，新到达的读者会立即被允许进入读取区，而写者则会被阻塞，直到所有读者都离开读取区。读者优先策略可能会导致写者饥饿（即写者长时间无法获得写入权限），特别是当读者频繁到达时。
写者优先策略
在这种策略中，系统会优先考虑写者。当写者请求写入权限时，系统会尽快地让写者进入写入区，即使此时有读者正在读取。这通常意味着一旦有写者到达，所有后续的读者都会被阻塞，直到写者完成写入并离开写入区。写者优先策略可以减少写者等待的时间，但可能会导致读者饥饿（即读者长时间无法获得读取权限），特别是当写者频繁到达时。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
