6种形式:1、互斥锁,本质就是一个特殊的全局变量,拥有lock和unlock两种状态;2、自旋锁,是一个死循环,不停的寻址;3、信号量linux 虚拟主机,用于控制访问有限共享资源的线程数;4、条件变量
6种形式:1、互斥锁,本质就是一个特殊的全局变量linux删除命令,拥有lock和unlock两种状态;2、自旋锁,是一个死循环,不停的寻址;3、信号量,用于控制访问有限共享资源的线程数;4、条件变量,可以让调用线程在满足特定条件的情况下运行,不满足条件时阻塞等待被唤起;5、读写锁,一次只能有一个线程可以占有写模式的读写锁;6、屏障,是用户协调多个线程并行工作的同步机制。
程序员必备插口测试调试工具:立刻使用
Apipost=Postman+Swagger+Mock+Jmeter
Api设计、调试、文档、自动化测试工具
前端、前端、测试,同时在线协作,内容实时同步
本教程操作环境:linux7.3系统、DellG3笔记本。
linux中实现线程同步的6种方式
下边是一个线程不安全的事例:
#include #include int ticket_num=10000000; void *sell_ticket(void *arg) { while(ticket_num>0) { ticket_num--; } } int main() { pthread_t t1,t2,t3; pthread_create(&t1, NULL, &sell_ticket, NULL); pthread_create(&t2, NULL, &sell_ticket, NULL); pthread_create(&t3, NULL, &sell_ticket, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); printf("ticket_num=%dn", ticket_num); return 0; }
登陆后复制
运行结果如下:
# gcc no_lock_demo.c -o no_lock_demo.out -pthread # ./no_lock_demo.out ticket_num=-2
登陆后复制
最后运行的结果不是固定的,有可能是0、-1,假若有这个ticket_num变量代表是库存的话,这么都会出现库存为正数的情况,所以须要引入线程同步来保证线程安全。
Linux下提供了多种方法来处理线程同步,最常用的是互斥锁、自旋锁、信号量。
互斥锁
互斥锁本质就是一个特殊的全局变量,拥有lock和unlock两种状态,unlock的互斥锁可以由某个线程获得,当互斥锁由某个线程持有后,这个互斥锁会锁上弄成lock状态,随后只有该线程有权利打开该锁,其他想要获得该互斥锁的线程就会阻塞,直至互斥锁被解锁。
互斥锁的类型:
相关技巧:
// 静态方式创建互斥锁 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 动态方式创建互斥锁,其中参数mutexattr用于指定互斥锁的类型,具体类型见上面四种,如果为NULL,就是普通锁。 int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr); int pthread_mutex_lock(pthread_mutex_t *mutex); // 加锁,阻塞 int pthread_mutex_trylock(pthread_mutex_t *mutex); // 尝试加锁,非阻塞 int pthread_mutex_unlock(pthread_mutex_t *mutex); // 解锁
登陆后复制
事例:
#include #include int ticket_num=10000000; pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; void *sell_ticket(void *arg) { while(ticket_num>0) { pthread_mutex_lock(&mutex); if(ticket_num>0) { ticket_num--; } pthread_mutex_unlock(&mutex); } } int main() { pthread_t t1,t2,t3; pthread_create(&t1, NULL, &sell_ticket, NULL); pthread_create(&t2, NULL, &sell_ticket, NULL); pthread_create(&t3, NULL, &sell_ticket, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); printf("ticket_num=%dn", ticket_num); return 0; }
登陆后复制载流子锁
载流子锁顾名思义就是一个死循环,不停的寻址linux线程间同步方式,当一个线程未获得载流子锁时,不会像互斥锁一样步入阻塞休眠状态,而是不停的寻址获取锁,假如载流子锁才能很快被释放,这么性能还会很高linux线程间同步方式,假如载流子锁长时间不能否被释放,甚至上面还有大量的IO阻塞,都会造成其他获取锁的线程仍然空协程,致使CPU使用率达到100%,非常CPU时间。
相关技巧:
int pthread_spin_init(pthread_spinlock_t *lock, int pshared); // 创建自旋锁 int pthread_spin_lock(pthread_spinlock_t *lock); // 加锁,阻塞 int pthread_spin_trylock(pthread_spinlock_t *lock); // 尝试加锁,非阻塞 int pthread_spin_unlock(pthread_spinlock_t *lock); // 解锁
登陆后复制
事例:
#include #include int ticket_num=10000000; pthread_spinlock_t spinlock; void *sell_ticket(void *arg) { while(ticket_num>0) { pthread_spin_lock(&spinlock); if(ticket_num>0) { ticket_num--; } pthread_spin_unlock(&spinlock); } } int main() { pthread_spin_init(&spinlock, 0); pthread_t t1,t2,t3; pthread_create(&t1, NULL, &sell_ticket, NULL); pthread_create(&t2, NULL, &sell_ticket, NULL); pthread_create(&t3, NULL, &sell_ticket, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); printf("ticket_num=%dn", ticket_num); return 0; }
登陆后复制讯号量
讯号量是一个计数器,用于控制访问有限共享资源的线程数。
相关技巧:
// 创建信号量 // pshared:一般取0,表示调用进程的信号量。非0表示该信号量可以共享内存的方式,为多个进程所共享(Linux暂不支持)。 // value:信号量的初始值,可以并发访问的线程数。 int sem_init (sem_t* sem, int pshared, unsigned int value); int sem_wait (sem_t* sem); // 信号量减1,信号量为0时就会阻塞 int sem_trywait (sem_t* sem); // 信号量减1,信号量为0时返回-1,不阻塞 int sem_timedwait (sem_t* sem, const struct timespec* abs_timeout); // 信号量减1,信号量为0时阻塞,直到abs_timeout超时返回-1 int sem_post (sem_t* sem); // 信号量加1
登陆后复制
事例:
#include #include #include int ticket_num=10000000; sem_t sem; void *sell_ticket(void *arg) { while(ticket_num>0) { sem_wait(&sem); if(ticket_num>0) { ticket_num--; } sem_post(&sem); } } int main() { sem_init(&sem, 0, 1); // value=1表示最多1个线程同时访问共享资源,与互斥量等价 pthread_t t1,t2,t3; pthread_create(&t1, NULL, &sell_ticket, NULL); pthread_create(&t2, NULL, &sell_ticket, NULL); pthread_create(&t3, NULL, &sell_ticket, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); printf("ticket_num=%dn", ticket_num); return 0; }
登陆后复制条件变量
条件变量可以让调用线程在满足特定条件的情况下运行,不满足条件时阻塞等待被唤起,必须与互斥锁搭配使用。
条件变量常用于生产者与消费者模型。
相关方式:
pthread_cond_t cond=PTHREAD_COND_INITIALIZER; // 创建条件变量,一个互斥锁可以对应多个条件变量 int pthread_cond_wait (pthread_cond_t* cond,pthread_mutex_t* mutex); // 阻塞等待条件满足,同时释放互斥锁mutex int pthread_cond_timedwait (pthread_cond_t* cond, pthread_mutex_t* mutex, const struct timespec* abstime); // 带超时的阻塞等待条件满足,同时释放互斥锁mutex // 从条件变量cond中唤出一个线程,令其重新获得原先的互斥锁 // 被唤出的线程此刻将从pthread_cond_wait函数中返回,但如果该线程无法获得原先的锁,则会继续阻塞在加锁上。 int pthread_cond_signal (pthread_cond_t* cond); // 从条件变量cond中唤出所有线程 int pthread_cond_broadcast (pthread_cond_t* cond);
登陆后复制
事例:
#include #include int max_buffer=10; int count=0; pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; pthread_cond_t notempty=PTHREAD_COND_INITIALIZER; pthread_cond_t notfull=PTHREAD_COND_INITIALIZER; void *produce(void *args) { while(1) { pthread_mutex_lock(&mutex); while(count == max_buffer) { printf("buffer is full, wait...n"); pthread_cond_wait(¬full, &mutex); } printf("produce ...n"); count++; sleep(1); pthread_cond_signal(¬empty); pthread_mutex_unlock(&mutex); } } void *consumer(void *args) { while(1) { pthread_mutex_lock(&mutex); while(count == 0) { printf("buffer is empty, wait...n"); pthread_cond_wait(¬empty, &mutex); } printf("consumer ...n"); count--; sleep(1); pthread_cond_signal(¬full); pthread_mutex_unlock(&mutex); } } int main() { pthread_t t1,t2,t3,t4; pthread_create(&t1, NULL, &produce, NULL); pthread_create(&t2, NULL, &produce, NULL); pthread_create(&t3, NULL, &consumer, NULL); pthread_create(&t4, NULL, &consumer, NULL); pthread_join(t1, NULL); return 0; }
登陆后复制读写锁
读写锁可以有三种状态:读模式下加锁状态,写模式下加锁状态,不加锁状态。一次只有一个线程可以占有写模式的读写锁,并且多个线程可以同时占有读模式的读写锁。读写锁也称作共享-独占锁,当读写锁以读模式锁住时,它是以共享模式锁住的,当它以写模式锁住时,它是以独占模式锁住的,读读共享,读写互斥。
一次只能有一个线程可以占有写模式的读写锁,并且多个线程可以同时战友读模式的读写锁。因而与互斥量相比,读写锁容许更高的并行性。读写锁特别适宜对数据结构读的次数远小于写的情况。
相关技巧:
// 创建读写锁 pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER; int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); // 加读锁,阻塞 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); // 加写锁,阻塞 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); // 释放读锁或者写锁 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); // 尝试加读锁,非阻塞 int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); // 尝试加写锁,非阻塞
登陆后复制
事例:
#include #include pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER; void *read(void *arg) { while(1) { pthread_rwlock_rdlock(&rwlock); rintf("read message.n"); sleep(1); pthread_rwlock_unlock(&rwlock); sleep(1); } } void *write(void *arg) { while(1) { pthread_rwlock_wrlock(&rwlock); printf("write message.n"); sleep(1); pthread_rwlock_unlock(&rwlock); sleep(1); } } int main(int argc,char *argv[]) { pthread_t t1,t2,t3; pthread_create(&t1, NULL, &read, NULL); pthread_create(&t2, NULL, &read, NULL); pthread_create(&t3, NULL, &write, NULL); pthread_join(t1, NULL); return 0; }
登陆后复制屏障
屏障(barrier)是用户协调多个线程并行工作的同步机制。屏障容许每位线程等待,直至所有的合作线程都抵达某一点,之后所有线程都从该点继续执行。pthread_join函数就是一种屏障,容许一个线程等待,直至另一个线程退出。但屏障对象的概念更广,容许任意数目的线程等待,直至所有的线程完成处理工作,而线程不须要退出,当所有的线程达到屏障后可以接着工作。
相关技巧:
// 创建屏障 int pthread_barrier_init(pthread_barrier_t *barrier,const pthread_barrrierattr_t *attr,unsigned int count) // 阻塞等待,直到所有线程都到达 int pthread_barrier_wait(pthread_barrier_t *barrier)
登陆后复制
事例:
#include #include pthread_barrier_t barrier; void *go(void *arg){ sleep (rand () % 10); printf("%lu is arrived.n", pthread_self()); pthread_barrier_wait(&barrier); printf("%lu go shopping...n", pthread_self()); } int main() { pthread_barrier_init(&barrier, NULL, 3); pthread_t t1,t2,t3; pthread_create(&t1, NULL, &go, NULL); pthread_create(&t2, NULL, &go, NULL); pthread_create(&t3, NULL, &go, NULL); pthread_join(t1, NULL); return 0; }
登陆后复制