1. 全栈程序员必看首页

linux中实现线程同步的6种方法

全栈程序员-站长 • • 未分类 • 阅读 16

linux中实现线程同步的6种方法linux线程同步的方法下面是一个线程不安全的例子：#include<stdio.h>#include<pthread.h>intticket_num=10000000;void*sell_ticket(void*arg){while(ticket_num>0){ ticket_num–;}}intmain(){pthread_tt1,t2,t3;pthread_create(&t1,NU

大家好，又见面了，我是你们的朋友全栈君。

linux线程同步的方法

下面是一个线程不安全的例子：

#include<stdio.h>
#include<pthread.h>

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=%d\n", 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_NORMAL）：互斥锁默认类型。当一个线程对一个普通锁加锁以后，其余请求该锁的线程将形成一个 等待队列，并在该锁解锁后按照优先级获得它，这种锁类型保证了资源分配的公平性。一个 线程如果对一个已经加锁的普通锁再次加锁，将引发死锁；对一个已经被其他线程加锁的普 通锁解锁，或者对一个已经解锁的普通锁再次解锁，将导致不可预期的后果。

  • 检错锁（PTHREAD_MUTEX_ERRORCHECK）：一个线程如果对一个已经加锁的检错锁再次加锁，则加锁操作返回EDEADLK；对一个已 经被其他线程加锁的检错锁解锁或者对一个已经解锁的检错锁再次解锁，则解锁操作返回 EPERM。

  • 嵌套锁（PTHREAD_MUTEX_RECURSIVE）：该锁允许一个线程在释放锁之前多次对它加锁而不发生死锁；其他线程要获得这个锁，则当前锁的拥有者必须执行多次解锁操作；对一个已经被其他线程加锁的嵌套锁解锁，或者对一个已经解锁的嵌套锁再次解锁，则解锁操作返回EPERM。

  • 默认锁（PTHREAD_MUTEX_ DEFAULT）：一个线程如果对一个已经加锁的默认锁再次加锁，或者虽一个已经被其他线程加锁的默 认锁解锁，或者对一个解锁的默认锁解锁，将导致不可预期的后果；这种锁实现的时候可能 被映射成上述三种锁之一。

相关方法：


// 静态方式创建互斥锁
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<stdio.h>
#include<pthread.h>

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=%d\n", ticket_num);
    return 0;
}

自旋锁

自旋锁顾名思义就是一个死循环，不停的轮询，当一个线程未获得自旋锁时，不会像互斥锁一样进入阻塞休眠状态，而是不停的轮询获取锁，如果自旋锁能够很快被释放，那么性能就会很高，如果自旋锁长时间不能够被释放，甚至里面还有大量的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<stdio.h>
#include<pthread.h>

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=%d\n", 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<stdio.h>
#include<pthread.h>
#include <semaphore.h>

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=%d\n", 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<stdio.h>
#include<pthread.h>

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(&notfull, &mutex);
        }
        printf("produce ...\n");
        count++;
        sleep(1);
        pthread_cond_signal(&notempty);
        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(&notempty, &mutex);
        }
        printf("consumer ...\n");
        count--;
        sleep(1);
        pthread_cond_signal(&notfull);
        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 <stdio.h>
#include <pthread.h>

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 <stdio.h>
#include <pthread.h>

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;
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/159705.html原文链接：https://javaforall.net

赞 (0)
全栈程序员-站长的头像全栈程序员-站长
0 0

相关推荐

  • 各位学弟学妹，别再看教材了，时间复杂度看这篇就好了[通俗易懂]

    各位学弟学妹，别再看教材了，时间复杂度看这篇就好了[通俗易懂]

    各位学弟学妹，别再看教材了，时间复杂度看这篇就好了[通俗易懂]时间复杂度是学习算法的基石，今天我们来聊聊为什么要引入时间复杂度，什么是时间复杂度以及如何去算一个算法的时间复杂度一、刻画算法的运行时间某日，慧能叫来了一尘打算给他补习补习一下基础知识，只见克写了一段非常简单的代码一尘看老师有点生气，开始虚心请教了为了方便讨论，这里我们把每一条语句的执行时间都看做是一样的，记为一个时间单元①蓝色框的两条语句，花费两个时间单元②黑色框的一条语句，花费n+1个时间单元③红色框的两条语句，花费2*n个时间单元这不是.

    全栈程序员-站长的头像 全栈程序员-站长
    2022年5月15日
  • 小程序bindtap传参_微信小程序bindtap

    小程序bindtap传参_微信小程序bindtap

    小程序bindtap传参_微信小程序bindtap一边开发一边做点笔记，东西可能零散了点，一边开发一边补充。1、事件 1.bindtap绑定点击事件 2.bindinput监听输入，没输入一个字符得到一次返回值（就算是输入中文时，没敲一次键依然返回一次）2、解决小程序tabBar跳转不能带参数问题小程序这里遇到了一个难题就是如果实现tabBar栏之间的跳转的话是不能传入参数的那么我们要如何解决这个问题呢！ 我的办法就是让你的传…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年11月2日
  • pycharm2021年激活码刚出 3月最新注册码 idea

    pycharm2021年激活码刚出 3月最新注册码

    pycharm2021年激活码刚出 3月最新注册码，https://javaforall.net/100143.html。详细ieda激活码不妨到全栈程序员必看教程网一起来了解一下吧！

    全栈程序员-站长的头像 全栈程序员-站长
    2022年3月15日
  • 常用的安全渗透测试工具(渗透测试工具)

    常用的安全渗透测试工具(渗透测试工具)

    应用程序安全性并不新鲜，但它在需求、复杂性和深度方面正迅速增长。随着网络犯罪自疫情爆发以来增长了近600%，越来越多的SaaS企业开始争相保护他们的应用程序。即使那些运行最新端点保护的系统也面临重大漏洞。然而随之而来的一个问题是：即便采取了这些安全防护措施，能保护自己不会受到网络攻击吗?答案在于应用程序安全测试解决方案，该解决方案可以主动测试您的代码是否存在错误、关键漏洞和需要全面改进的领域。接下来是常见几种测试。 渗透测试 部署自动化工具，如SAST、DAST、RAST和IAST

    全栈程序员-站长的头像 全栈程序员-站长
    2022年4月16日
  • <span>机器学习常见问题</span>

    机器学习常见问题

    机器学习常见问题

    全栈程序员-站长的头像 全栈程序员-站长
    2021年11月19日
  • STM32驱动1602A 8086协议[通俗易懂]

    STM32驱动1602A 8086协议[通俗易懂]

    STM32驱动1602A 8086协议[通俗易懂]本来想学I2C发现1602上没有I2C的接口，他是8086并口的就先把它搞了//1602的外设文件#include“lcd1602.h”#include“sys.h”#include“delay.h”#include“stdio.h”voidGPIO_Configuration(void){GPIO_InitTypeDefGPIO_InitStructure;R…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年9月22日

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号