【Linux】线程——线程池、线程池的实现、线程安全的线程池、单例模式的概 ...

Linux线程

7. 线程池

  线程池是一种多线程编程中的技术和概念。
  它是一种线程使用模式。是一组预先创建好的线程聚集，这些线程处于等待状态，随时预备担当任务并实行。

  
7.1 线程池介绍

为什么使用线程池
  线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发实行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
  
线程池的应用场景
  （1）必要大量的线程来完成任务，且完成任务的时间比力短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不显着了。因为Telnet会话时间比线程的创建时间大多了。
  （2）对性能要求苛刻的应用，比如要求服务器迅速相应客户请求。
  （3）担当突发性的大量请求，但不至于使服务器因此产生大量线程的应用。 突发性大量客户请求，在没有线程池环境下，将产生大量线程，固然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。
  
使用线程池的优点
  （1）提高性能：避免了频繁创建和销毁线程的开销，因为线程的创建和销毁是比力耗时的操作。
  （2）控制资源：可以限定线程的数量，防止过多的线程竞争系统资源，导致系统性能降落乃至崩溃。
  （3）提高相应性：能够更快地相应新的任务请求，因为线程已经预备好，无需等待线程创建。
  
7.2 线程池的实现

线程池示例
  （1）创建固定命量线程池，循环从任务队列中获取任务对象。
  （2）获取到任务对象后，实行任务对象中的任务接口。
  
实行任务：

1. #pragma once
2. #include <iostream>
3. #include <string>
5. std::string opers="+-*/%";
7. enum{
8.     DivZero=1,
9.     ModZero,
10.     Unknown
11. };
13. class Task
14. {
15. public:
16.     Task()
17.     {}
18.    
19.     Task(int x,int y,char op)
20.         :_data1(x),_data2(y),_oper(op),_result(0),_exitcode(0)
21.     {}
23.     void run()
24.     {
25.         switch (_oper)
26.         {
27.         case '+':
28.             _result=_data1+_data2;
29.             break;
30.         case '-':
31.             _result=_data1-_data2;
32.             break;
33.         case '*':
34.             _result=_data1*_data2;
35.             break;
36.         case '/':
37.             {
38.                 if(_data2==0) _exitcode=DivZero;
39.                 else _result=_data1/_data2;
40.             }
41.             break;
42.         case '%':
43.             {
44.                 if(_data2==0) _exitcode=ModZero;
45.                 else _result=_data1%_data2;
46.             }
47.             break;
48.         default:
49.             _exitcode=Unknown;
50.             break;
51.         }
52.     }
54.     //Task对象重载运算符(),()直接进行run函数
55.     void operator()()
56.     {
57.         run();
58.     }
60.     std::string GetResult()
61.     {
62.         std::string r=std::to_string(_data1);
63.         r+=_oper;
64.         r+=std::to_string(_data2);
65.         r+="=";
66.         r+=std::to_string(_result);
67.         r+="[code: ";
68.         r+=std::to_string(_exitcode);
69.         r+="]";
71.         return r;
72.     }
74.     std::string GetTask()
75.     {
76.         std::string r=std::to_string(_data1);
77.         r+=_oper;
78.         r+=std::to_string(_data2);
79.         r+="=?";
80.         return r;
81.     }
83.     ~Task()
84.     {}
86. private:
87.     int _data1;
88.     int _data2;
89.     char _oper;
91.     int _result;
92.     int _exitcode;
93. };

复制代码

  
线程池：

1. #pragma once
3. #include <iostream>
4. #include <vector>
5. #include <queue>
6. #include <string>
7. #include <pthread.h>
8. #include <unistd.h>
9. #include "Task.hpp"
11. struct ThreadData
12. {
13.     pthread_t tid;
14.     std::string name;
15. };
17. static const int defaultnum=5; //默认线程数量
19. //实现我们的线程池
20. template<class T>
21. class ThreadPool
22. {
23. public:
24.     void Lock()
25.     {
26.         pthread_mutex_lock(&_mutex);
27.     }
29.     void Unlock()
30.     {
31.         pthread_mutex_unlock(&_mutex);
32.     }
34.     void Wakeup()
35.     {
36.         pthread_cond_signal(&_cond);
37.     }
39.     void ThreadSleep()
40.     {
41.         pthread_cond_wait(&_cond,&_mutex);
42.     }
44.     bool IsQueueEmpty()
45.     {
46.         return _tasks.empty();
47.     }
49. public:
50.     //注意我们线程调用的函数要求参数和返回值都是void*
51.     //但是handler在类中默认有this指针->参数不匹配，可以bind或者声明static或放在类外
52.     static void *Handler(/*ThreadPool *this,*/void *args)
53.     {
54.         ThreadPool<T> *tp=static_cast<ThreadPool<T>*>(args);
55.         while(true)
56.         {
57.             tp->Lock();
58.             
59.             while(tp->IsQueueEmpty()) //判断任务是否为空
60.             {
61.                 tp->ThreadSleep(); //条件变量
62.             }
63.             T t=tp->Pop(); //取出任务
65.             tp->Unlock();
66.             t(); //处理任务
68.             std::cout<<" run, "<<"result: "<< t.GetResult()<<std::endl;            
69.         }
70.         return nullptr;
71.     }
73.     void Start() //启动线程池
74.     {
75.         int num=_threads.size();
76.         for(int i=0;i<num;i++)
77.         {
78.             _threads[i].name="thread-"+std::to_string(i+1);
79.             pthread_create(&(_threads[i].tid),nullptr,Handler,this);
80.         }
81.     }
83.     void Push(const T &t) //向任务队列放入任务
84.     {
85.         Lock();
86.         _tasks.push(t); //放入任务
87.         Wakeup(); //唤醒线程
88.         Unlock();
89.     }
91.     T Pop() //取出任务
92.     {
93.         T t=_tasks.front();
94.         _tasks.pop();
95.         return t;
96.     }
98.     ThreadPool(int num=defaultnum)
99.         :_threads(num)
100.     {
101.         pthread_mutex_init(&_mutex,nullptr);
102.         pthread_cond_init(&_cond,nullptr);
103.     }
105.     ~ThreadPool()
106.     {
107.         pthread_mutex_destroy(&_mutex);
108.         pthread_cond_destroy(&_cond);
109.     }
111. private:   
112.     std::vector<ThreadData> _threads; //线程池
113.     std::queue<T> _tasks; //任务队列
115.     pthread_mutex_t _mutex; //锁
116.     pthread_cond_t _cond; //条件变量
117. };

复制代码

  
运行函数：

1. #include <iostream>
2. #include "ThreadPool.hpp"
4. int main()
5. {
6.     ThreadPool<Task> *tp=new ThreadPool<Task>(5);
7.     tp->Start();
9.     srand(time(nullptr) ^ getpid());   
11.     while(true)
12.     {
13.         //1. 构建任务
14.         int x=rand()%10+1;
15.         usleep(10);
16.         int y=rand()%5;
17.         char op=opers[rand()%opers.size()];
19.         Task t(x,y,op);
20.         tp->Push(t);
21.         //2. 交给线程池处理
22.         std::cout<<"main thread make task: "<<t.GetTask()<<std::endl;
24.         sleep(1);
25.     }
27.     return 0;
28. }

复制代码

  

  
7.3 线程安全的线程池

7.3.1 单例模式的概念

  单例模式是一种常见的软件计划模式。
  概念：单例模式确保一个类只有一个实例存在，并提供一个全局访问点来获取该实例。
  
特点包罗
  唯一性：保证一个类在整个应用程序中只有一个实例。
  全局访问：提供了一种全局访问这个唯一实例的方式，方便在程序的任何地方使用。
  延迟初始化：通常实例的创建是延迟的，即在首次使用时才创建实例，以提高性能和资源利用率。
  
单例模式的优点
  节流系统资源：避免了频繁创建和销毁对象带来的资源消耗。
  统一管理：对唯一的实例进行集中管理和控制，方便维护和修改。
  保证一致性：在整个应用中，对于共享的数据或状态，通过单例模式可以保证其一致性。
  
7.3.2 饿汉和懒汉模式

  饿汉模式：
  在类加载时就创建单例对象。
  优点：线程安全， 因为对象在类加载时就已经创建好了，不存在多线程并发创建的问题。简单直接，实现较为简单。
  缺点：无论是否使用，对象都会在类加载时创建，可能会造成肯定的资源浪费。

1. template <typename T>
2. class Singleton
3. {
4.         static T data;
5.        
6. public:
7.         static T* GetInstance()
8.         {
9.                 return &data;
10.         }
11. };

复制代码

  
  懒汉模式：
  在第一次使用时才创建单例对象。
  优点：延迟对象的创建，只有在真正必要时才创建，节流了资源。
  缺点：线程不安全，在多线程环境下可能会创建多个实例。必要额外的处理来保证线程安全，增加了实现的复杂性。

1. template <typename T>
2. class Singleton
3. {
4.         static T* inst;
6. public:
7.         static T* GetInstance()
8.         {
9.                 if (inst == NULL)
10.                 {
11.                         inst = new T();
12.                 }
13.                 return inst;
14.         }
15. };

复制代码

  
懒汉模式实现线程安全的线程池
线程安全的线程池：

1. #pragma once
3. #include <iostream>
4. #include <vector>
5. #include <queue>
6. #include <string>
7. #include <pthread.h>
8. #include <unistd.h>
9. #include "Task.hpp"
11. struct ThreadData
12. {
13.     pthread_t tid;
14.     std::string name;
15. };
17. static const int defaultnum=5; //默认线程数量
19. //实现我们的线程池
20. template<class T>
21. class ThreadPool
22. {
23. public:
24.     void Lock()
25.     {
26.         pthread_mutex_lock(&_mutex);
27.     }
29.     void Unlock()
30.     {
31.         pthread_mutex_unlock(&_mutex);
32.     }
34.     void Wakeup()
35.     {
36.         pthread_cond_signal(&_cond);
37.     }
39.     void ThreadSleep()
40.     {
41.         pthread_cond_wait(&_cond,&_mutex);
42.     }
44.     bool IsQueueEmpty()
45.     {
46.         return _tasks.empty();
47.     }
49.     std::string GetThreadName(pthread_t tid)
50.     {
51.         for (const auto &ti : _threads)
52.         {
53.             if (ti.tid == tid)
54.                 return ti.name;
55.         }
56.         return "None";
57.     }
59. public:
60.     //注意我们线程调用的函数要求参数和返回值都是void*
61.     //但是handler在类中默认有this指针->参数不匹配，可以bind或者声明static或放在类外
62.     static void *Handler(/*ThreadPool *this,*/void *args)
63.     {
64.         ThreadPool<T> *tp=static_cast<ThreadPool<T>*>(args);
65.         std::string name = tp->GetThreadName(pthread_self());
66.         while(true)
67.         {
68.             tp->Lock();
69.             
70.             while(tp->IsQueueEmpty()) //判断任务是否为空
71.             {
72.                 tp->ThreadSleep(); //条件变量
73.             }
74.             T t=tp->Pop(); //取出任务
76.             tp->Unlock();
77.             t(); //处理任务
79.             std::cout<<name<<" run, "<<"result: "<< t.GetResult()<<std::endl;            
80.         }
81.         return nullptr;
82.     }
84.     void Start() //启动线程池
85.     {
86.         int num=_threads.size();
87.         for(int i=0;i<num;i++)
88.         {
89.             _threads[i].name="thread-"+std::to_string(i+1);
90.             pthread_create(&(_threads[i].tid),nullptr,Handler,this);
91.         }
92.     }
94.     void Push(const T &t) //向任务队列放入任务
95.     {
96.         Lock();
97.         _tasks.push(t); //放入任务
98.         Wakeup(); //唤醒线程
99.         Unlock();
100.     }
102.     T Pop() //取出任务
103.     {
104.         T t=_tasks.front();
105.         _tasks.pop();
106.         return t;
107.     }
109.     static ThreadPool<T> *GetInstance() //获取单例对象
110.     {
111.         if(nullptr==_tp) //创建单例对象后，不会再有申请和释放锁的操作
112.         {
113.             pthread_mutex_lock(&_lock); //保护临界资源
114.             if(_tp==nullptr)
115.             {
116.                 std::cout<<"singleton create done"<<std::endl;
117.                 _tp=new ThreadPool<T>();
118.             }
119.             pthread_mutex_unlock(&_lock);
120.         }
122.         return _tp;
123.     }
125. private:
126.     ThreadPool(const ThreadPool<T>&)=delete;
127.     const ThreadPool<T>& operator=(const ThreadPool<T>&)=delete;
128.    
129.     ThreadPool(int num=defaultnum)
130.         :_threads(num)
131.     {
132.         pthread_mutex_init(&_mutex,nullptr);
133.         pthread_cond_init(&_cond,nullptr);
134.     }
136.     ~ThreadPool()
137.     {
138.         pthread_mutex_destroy(&_mutex);
139.         pthread_cond_destroy(&_cond);
140.     }
142. private:   
143.     std::vector<ThreadData> _threads; //线程池
144.     std::queue<T> _tasks; //任务队列
146.     pthread_mutex_t _mutex; //锁
147.     pthread_cond_t _cond; //条件变量
149.     static ThreadPool<T> *_tp; //获取单例指针
150.     static pthread_mutex_t _lock; //锁
151. };
153. template<class T>
154. ThreadPool<T> *ThreadPool<T>::_tp=nullptr;
156. template<class T>
157. pthread_mutex_t ThreadPool<T>::_lock=PTHREAD_MUTEX_INITIALIZER;

复制代码

  
运行函数：

1. #include <iostream>
2. #include "ThreadPool.hpp"
4. int main()
5. {
6.     //ThreadPool<Task> *tp=new ThreadPool<Task>(5);
7.     //tp->Start();
8.     sleep(2); //懒汉模式
9.     ThreadPool<Task>::GetInstance()->Start();
10.     srand(time(nullptr) ^ getpid());   
12.     while(true)
13.     {
14.         //1. 构建任务
15.         int x=rand()%10+1;
16.         usleep(10);
17.         int y=rand()%5;
18.         char op=opers[rand()%opers.size()];
20.         Task t(x,y,op);
21.         //tp->Push(t);
22.         ThreadPool<Task>::GetInstance()->Push(t);
23.         //2. 交给线程池处理
24.         std::cout<<"main thread make task: "<<t.GetTask()<<std::endl;
26.         sleep(1);
27.     }
29.     return 0;
30. }

复制代码

  

  
STL中的容器是否是线程安全的?
  不是。原因是 STL 的计划初衷是将性能发掘到极致，而一旦涉及到加锁保证线程安全，会对性能造成巨大的影响。
  而且对于差别的容器，加锁方式的差别，性能可能也差别(例如hash表的锁表和锁桶)。
因此 STL 默认不是线程安全。假如必要在多线程环境下使用，往往必要调用者自行保证线程安全。
  
智能指针是否是线程安全的?
  对于 unique_ptr，由于只是在当前代码块范围内生效，因此不涉及线程安全问题。
  对于 shared_ptr，多个对象必要共用一个引用计数变量，所以会存在线程安全问题。但是尺度库实现的时间思量到了这个问题，基于原子操作(CAS)的方式保证 shared_ptr 能够高效， 原子的操作引用计数。
  
8. 常见锁使用汇总

8.1 互斥锁（Mutex）

  确保在同一时候只有一个线程能够访问被保护的资源。
  例如，多个线程同时操作一个共享的全局变量时，使用互斥锁来保证数据的一致性。
  
  初始化互斥锁

1. int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

复制代码

作用：初始化一个互斥锁。
参数：
  mutex：指向要初始化的互斥锁的指针。
  attr：互斥锁的属性指针，通常为 NULL（使用默认属性）。
返回值：乐成返回 0，失败返回错误码。
  
  加锁

1. int pthread_mutex_lock(pthread_mutex_t *mutex);

复制代码

作用：获取互斥锁，假如锁已被占用则壅闭等待。
参数：mutex：要加锁的互斥锁指针。
返回值：乐成返回 0，失败返回错误码。
  
  尝试加锁

1. int pthread_mutex_trylock(pthread_mutex_t *mutex);

复制代码

作用：尝试获取互斥锁，假如锁可用则获取并返回 0，否则立刻返回 EBUSY。
参数：mutex：要尝试加锁的互斥锁指针。
返回值：乐成返回 0，锁不可用返回 EBUSY。
  
  解锁

1. int pthread_mutex_unlock(pthread_mutex_t *mutex);

复制代码

作用：释放已获取的互斥锁。
参数：mutex：要解锁的互斥锁指针。
返回值：乐成返回 0，失败返回错误码。
  
  销毁互斥锁

1. int pthread_mutex_destroy(pthread_mutex_t *mutex);

复制代码

作用：销毁指定的互斥锁。
参数：mutex：要销毁的互斥锁指针。
返回值：乐成返回 0，失败返回错误码。
  
8.2 条件变量（Condition Variable）

  通常与互斥锁共同使用，用于线程之间的等待和关照。
  比如一个线程必要等待某个条件满足后才能继续实行，而另一个线程在条件满足时关照它。
  
  初始化条件变量

1. int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

复制代码

作用：初始化一个条件变量。
参数：
  cond：指向要初始化的条件变量的指针。
  attr：条件变量的属性指针，通常为 NULL（使用默认属性）。
返回值：乐成返回 0，失败返回错误码。
  
  等待条件变量

1. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

复制代码

作用：壅闭当前线程，直到指定的条件变量被唤醒。
参数：
  cond：要等待的条件变量指针。
  mutex：与条件变量关联的互斥锁指针。
返回值：乐成返回 0，失败返回错误码。
  
  定时等待条件变量

1. int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

复制代码

作用：壅闭当前线程，直到指定的条件变量被唤醒或到达指定的超时时间。
参数：
  cond：要等待的条件变量指针。
  mutex：与条件变量关联的互斥锁指针。
  abstime：指定的超时时间。
返回值：乐成返回 0，超时返回 ETIMEDOUT，失败返回其他错误码。
  
  唤醒一个等待条件变量的线程

1. int pthread_cond_signal(pthread_cond_t *cond);

复制代码

作用：唤醒至少一个等待指定条件变量的线程。
参数：cond：要唤醒的条件变量指针。
返回值：乐成返回 0，失败返回错误码。
  
  唤醒所有等待条件变量的线程

1. int pthread_cond_broadcast(pthread_cond_t *cond);

复制代码

作用：唤醒所有等待指定条件变量的线程。
参数：cond：要唤醒的条件变量指针。
返回值：乐成返回 0，失败返回错误码。
  
  销毁条件变量

1. int pthread_cond_destroy(pthread_cond_t *cond);

复制代码

作用：销毁指定的条件变量。
参数：cond：要销毁的条件变量指针。
返回值：乐成返回 0，失败返回错误码。
  
8.3 信号量（Semaphore）

  用于控制同时访问某一资源的线程数量。
  例如限定同时访问数据库连接的线程数量。
  
  初始化信号量

1. int sem_init(sem_t *sem, int pshared, unsigned int value);

复制代码

作用：初始化一个信号量。
参数：
  sem：指向要初始化的信号量的指针。
  pshared：表示信号量的共享属性，0 表示线程间共享，非 0 表示进程间共享。
  value：信号量的初始值。
返回值：乐成返回 0，失败返回 -1。
  
  等待信号量

1. int sem_wait(sem_t *sem);

复制代码

作用：等待信号量的值大于 0，然后将其减 1。
参数：sem：要操作的信号量指针。
返回值：乐成返回 0，失败返回 -1。
  
  尝试等待信号量

1. int sem_trywait(sem_t *sem);

复制代码

作用：尝试等待信号量，假如信号量的值大于 0，则将其减 1 并立刻返回；否则返回错误。
参数：sem：要操作的信号量指针。
返回值：乐成返回 0，信号量不可用返回 -1 并设置 errno 为 EAGAIN。
  
  释放信号量

1. int sem_post(sem_t *sem);

复制代码

作用：将信号量的值增加 1。
参数：sem：要操作的信号量指针。
返回值：乐成返回 0，失败返回 -1。
  
  获取信号量的值

1. int sem_getvalue(sem_t *sem, int *sval);

复制代码

作用：获取信号量的当前值，并将其存储在 sval 指向的变量中。
参数：
  sem：要操作的信号量指针。
  sval：用于存储信号量值的整数指针。
返回值：乐成返回 0，失败返回 -1。
  
  销毁信号量

1. int sem_destroy(sem_t *sem);

复制代码

作用：销毁指定的信号量。
参数：sem：要销毁的信号量指针。
返回值：乐成返回 0，失败返回 -1。
  
8.4 自旋锁（Spin Lock）

  线程在获取锁失败时，会不停循环尝试获取，而不是壅闭等待。
  适用于锁被持有的时间很短的环境，能避免线程切换的开销，但假如锁被长时间持有，会浪费 CPU 资源。
  
  初始化自旋锁

1. int spinlock_init(spinlock_t *lock, const spinlockattr_t *attr);

复制代码

作用：初始化指定的自旋锁。
参数：
  lock：指向要初始化的自旋锁的指针。
  attr：自旋锁属性指针，可为 NULL（使用默认属性）。
返回值：乐成返回 0，失败返回错误码。
  
  销毁自旋锁

1. int spinlock_destroy(spinlock_t *lock);

复制代码

作用：销毁指定的自旋锁。
参数：lock：要销毁的自旋锁指针。
返回值：乐成返回 0，失败返回错误码。
  
  尝试获取自旋锁（读）

1. int spinlock_rdlock(spinlock_t *lock);

复制代码

作用：尝试获取自旋锁的读锁。
参数：lock：指向要获取读锁的自旋锁的指针。
返回值：乐成返回 0，失败返回错误码。
  
  尝试获取自旋锁（写）

1. int spinlock_wrlock(spinlock_t *lock);

复制代码

作用：尝试获取自旋锁的写锁。
参数：lock：指向要获取写锁的自旋锁的指针。
返回值：乐成返回 0，失败返回错误码。
  
  释放自旋锁

1. int spinlock_unlock(spinlock_t *lock);

复制代码

作用：释放指定的自旋锁。
参数：lock：要释放的自旋锁指针。
返回值：乐成返回 0，失败返回错误码。
  
8.5 读写锁（Read-Write Lock）

  区分读操作和写操作。允很多个线程同时进行读操作，但在写操作时，不允许其他线程进行读或写操作。
  适用于读操作频繁而写操作较少的场景，比如共享数据的读取次数远多于修改次数的环境。

  
  初始化读写锁

1. int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
2.                                                 const pthread_rwlockattr_t *restrict attr);

复制代码

作用：初始化指定的读写锁。
参数：
  rwlock：指向要初始化的读写锁的指针。
  attr：读写锁属性指针，可为 NULL（使用默认属性）。
返回值：乐成返回 0，失败返回错误码。
  
  销毁读写锁

1. int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

复制代码

作用：销毁指定的读写锁。
参数：rwlock：要销毁的读写锁指针。
返回值：乐成返回 0，失败返回错误码。
  
  获取读写锁的读锁

1. int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

复制代码

作用：尝试获取指定读写锁的读锁。
参数：rwlock：指向要获取读锁的读写锁的指针。
返回值：乐成返回 0，失败返回错误码。
  
  获取读写锁的写锁

1. int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

复制代码

作用：尝试获取指定读写锁的写锁。
参数：rwlock：指向要获取写锁的读写锁的指针。
返回值：乐成返回 0，失败返回错误码。
  
  释放读写锁

1. int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

复制代码

作用：释放指定的读写锁。
参数：rwlock：要释放的读写锁指针。
返回值：乐成返回 0，失败返回错误码。
  
  设置读写锁的优先级

1. int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr, int pref);

复制代码

作用：设置读写锁的优先级。
参数：
  attr：读写锁属性指针。
  pref：优先级选择，有以下 3 种：
  PTHREAD_RWLOCK_PREFER_READER_NP （默认设置）读者优先，可能会导致写者饥饿环境。
  PTHREAD_RWLOCK_PREFER_WRITER_NP 写者优先，目前有 BUG，导致表现行为和 PTHREAD_RWLOCK_PREFER_READER_NP 一致。
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写者优先，但写者不能递归加锁。
返回值：乐成返回 0，失败返回错误码。
  
其他概念：
  悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被壅闭挂起。
  乐观锁：每次取数据时间，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要接纳两种方式：版本号机制和CAS操作。
  公平锁：公平锁按照线程请求锁的先后次序来分配锁。先请求的线程先获取，保证了次序公平。保证次序，得当要求严格公平的场景。但性能开销大，高并发时吞吐量可能受影响。
  非公平锁：非公平锁不按请求次序分配锁，锁释放时竞争的线程都可能获取，不肯定是先请求的。性能好，高并发时吞吐量可能高。但可能导致线程饥饿，行为不太确定。
  CAS操作：当必要更新数据时，判断当前内存值和之前取得的值是否相当。假如相当则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不停重试。
            

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。