C语言：2.5同步与死锁
C语言并发访问控制策略
C语言并发访问控制策略
对于编程语言而言，如何实现并发访问控制是一个关键问题。在C
语言中，为了保证多线程程序的正确性和安全性，需要采取一些策略
来管理并发访问。本文将讨论一些常见的C语言并发访问控制策略，
以及它们的优缺点。
一、互斥锁（Mutex）
互斥锁是最常见和基本的并发访问控制策略之一。它通过在关键代
码段前后加锁和解锁的方式，来确保同一时间只有一个线程可以访问
共享数据。在C语言中，可以使用`pthread_mutex_t`来创建和管理互斥锁。
优点：
1. 简单易用：使用互斥锁可以很方便地实现对共享资源的互斥访问。
2. 可靠性高：互斥锁能够保证同一时间只有一个线程可以访问共享
数据，避免了数据竞争的问题。
缺点：
1. 锁的开销：获取和释放锁会引入一定的开销，特别是当高并发频
繁地申请和释放锁时，会导致额外的开销。
2. 死锁风险：如果锁的获取和释放不当，容易出现死锁问题，导致
程序无法继续执行。
二、信号量（Semaphore）
信号量是一种更为灵活的并发访问控制策略。它可以控制对共享资源的访问数量，通过信号量的P操作和V操作来实现资源的加锁和解锁。在C语言中，可以使用`sem_t`来创建和管理信号量。
优点：
1. 灵活性高：信号量不仅可以用于简单的互斥访问控制，还可以用于控制对资源的并发访问数量。
2. 高效性能：相对于互斥锁，信号量在资源竞争不激烈的情况下，性能更高。
缺点：
1. 复杂度高：相比于互斥锁，信号量的使用和管理更为复杂，需要更多的代码实现和控制。
2. 容易导致资源泄漏：如果信号量没有正确释放，容易导致资源泄漏的问题。
c语言 锁原理
c语言锁原理
在计算机领域，锁是一种常用的同步机制，用于保护共享资源的访问。在并发编程中，多个线程同时操作共享资源时，如果没有合适的同步机制，就会导致数据不一致或者资源竞争的问题。而锁的作用就是确保在同一时刻只有一个线程能够访问共享资源，从而避免竞争条件的发生。
锁的实现原理可以分为两大类：互斥锁和读写锁。
互斥锁是一种最常见的锁机制，它保证在同一时刻只有一个线程能够执行被锁定的代码段。互斥锁的实现依赖于操作系统提供的原子操作，一般是通过硬件层面的原子指令来实现的。当一个线程尝试获取互斥锁时，如果锁已经被其他线程占用，那么该线程就会进入阻塞状态，直到锁被释放。互斥锁的实现可以使用各种算法，例如Peterson算法、TAS（Test-And-Set）、TTAS（Test-And-Test-And-Set）等。
读写锁是一种更加复杂的锁机制，它允许多个线程同时读取共享资源，但是只有一个线程能够进行写操作。读写锁的实现通常包括一个读锁和一个写锁。当一个线程获取读锁时，如果没有线程持有写锁，则可以立即获取锁；如果有线程持有写锁，则需要等待写锁释放。而当一个线程获取写锁时，需要等待所有的读锁和写锁都释放后才能获取锁。读写锁的实现可以使用各种算法，例如读者优先、
写者优先、公平锁等。
锁的实现原理与具体的编程语言和操作系统有关。在C语言中，可以使用标准库中提供的互斥锁（pthread_mutex_t）和读写锁（pthread_rwlock_t）来实现锁机制。这些锁的实现通常依赖于操作系统提供的底层原语，例如互斥锁可以使用操作系统提供的互斥量（Mutex）机制来实现。
进程间同步的几种方法
进程间同步的几种方法
进程间同步是指两个或多个进程之间进行协调，以确保它们能够正确地执行。这是多任务操作系统中的重要问题，因为进程之间共享资源，包括内存、文件和网络连接等。
进程同步的关键是确保一组进程在处理共享资源时，能够避免发生竞态条件（Race Condition）和死锁（Deadlock）。竞态条件指多个进程同时访问共享资源，导致不正确的结果。死锁指多个进程互相等待，导致它们都无法继续执行。
1. 互斥锁
互斥锁是最常见的同步方法之一，它被用来保护共享资源，确保同一时刻只有一个进程可以访问它。当一个进程获取了锁，其他进程必须等待，直到锁被释放。
在 POSIX 系统中，互斥锁可以通过 pthread_mutex_t 数据类型实现。我们可以使用pthread_mutex_init() 函数初始化锁，使用 pthread_mutex_lock() 函数获取锁，使用pthread_mutex_unlock() 函数释放锁。
下面是一个例子，展示了如何使用互斥锁同步两个进程对共享变量的访问：
```c
#include <pthread.h>
#include <stdio.h>
int count = 0;
pthread_mutex_t lock;
void *increment(void *arg) {
for (int i = 0; i < 1000000; i++) {
pthread_mutex_lock(&lock); // 获取锁
count++;
pthread_mutex_unlock(&lock); // 释放锁
什么是死锁以及避免死锁
什么是死锁以及避免死锁
⼀、定义
线程死锁是指由于两个或者多个线程互相持有对⽅所需要的资源，导致这些线程处于等待状态，⽆法前往执⾏。当线程进⼊对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调⽤wait⽅法，才释放资源，在此期间，其他线程将不能进⼊该代码块。当线程互相持有对⽅所需要的资源时，会互相等待对⽅释放资源，如果线程都不主动释放所占有的资源，将产⽣死锁。
当然死锁的产⽣是必须要满⾜⼀些特定条件的：
1.互斥条件：进程对于所分配到的资源具有排它性，即⼀个资源只能被⼀个进程占⽤，直到被该进程释放
2.请求和保持条件：⼀个进程因请求被占⽤资源⽽发⽣阻塞时，对已获得的资源保持不放。
3.不剥夺条件：任何⼀个资源在没被该进程释放之前，任何其他进程都⽆法对他剥夺占⽤
4.循环等待条件：当发⽣死锁时，所等待的进程必定会形成⼀个环路（类似于死循环），造成永久阻塞。
package com.sxy.thread;
/**
* 线程Thread1率先占有了resource1, 继续运⾏时需要resource2, 但此时resource2却被线程Thread2占有了，
* 因此只能等待Thread2释放resource2才能够继续运⾏；同时，Thread2也需要resource1,
* 它只能等待Thread1释放resource1才能够继续运⾏，因此，Thread1和Thread2都处于等待状态，
* 谁也⽆法继续运⾏，即产⽣了死锁。
*
* @author sunxy
*/
public class DeadLock {
C语言多线程编程与同步机制
C语言多线程编程与同步机制随着计算机技术的不断发展，多线程编程已成为现代程序设计的重要方面之一。C语言作为一种广泛应用于系统编程和嵌入式开发的语言，也需要具备多线程编程的能力。本文将介绍C语言多线程编程以及相关的同步机制。
一、多线程编程基础
多线程编程是指在一个程序中同时执行多个线程，这些线程可以并发执行，并与主线程并行工作。在C语言中，我们可以使用pthread库来实现多线程编程。
pthread库提供了一系列的函数用于创建、管理和同步线程。其中，常用的函数包括pthread_create、pthread_join、pthread_yield等。通过这些函数，我们可以创建线程、等待线程结束以及调度线程的执行顺序。
下面是一个简单的示例代码，展示了如何使用pthread库创建并执行多个线程：
```
#include <stdio.h>
#include <pthread.h>
#define NUM_THREADS 5
void* thread_func(void* arg) {
int thread_id = *(int*)arg;
printf("Hello from thread %d\n", thread_id);
pthread_exit(NULL);
}
int main() {
pthread_t threads[NUM_THREADS];
int thread_args[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; ++i) {
详解C语言进程同步机制
详解C语⾔进程同步机制
⽬录
1.进程同步的⼏个重要概念
2.软件同步机制
3.硬件同步机制
3.1 关中断
3.2 测试并建⽴（Test-and-Set, TS）指令
3.3 对换指令
4.信号量机制
4.1 整型信号量
4.2 记录型型号量
4.3 AND型信号量
4.4 信号量集
5.管程机制
6.总结
本⽂是对进程同步机制的⼀个⼤总结（9000+字吐⾎总结），涵盖⾯⾮常的全，包括了进程同步的⼀些概念、软件同步机制、硬件同步机制、信号量机制和管程机制，对每种机制结合代码做了详细的介绍，并且对琐碎的知识点和概念解释的⾮常清晰。
在前⾯的博客中讲述了进程的状态及其状态的转换，每种状态的含义和转换的原因。同样我们也知道，在OS引⼊了进程后，可以使系统中的多道程序可以并发的执⾏，进程的并发执⾏⼀⽅⾯极⼤的提⾼了系统的资源利⽤率和吞吐量，但是另⼀⽅⾯却使系统变得更加复杂，如果不能采取有效的措施，对多个进程的并发执⾏进⾏妥善的管理，必然会因为这些进程对系统资源的⽆序争夺给系统造成混乱，致使每次的处理结果显现出不可再现性。
对于上⾯的问题，⼤家想⼀想这么⼀个场景，如果我们在买⽕车票（just for 举栗⼦）时，没有排队这个机制，⼤家乱糟糟的围在售票员旁边，⼿⾥举着钱⼤叫来⼀张到xxx的硬座、来张到xxx的卧铺。。。咦，不寒⽽栗、可怕、脑壳痛。但是如果我们有序的排队购票，⼤家就都可以快速的买到⾃⼰想要的通往幸福的车票。
进程同步机制就是这么⼀个保障OS中多个进程能够有条不紊的运⾏的“规则”。本⽂中，我们将会详细的介绍⼏种进程同步机制。（本章中所讲的OS是单处理机系统，多处理机系统中的情况过于复杂，不利于理解）
C#线程系列讲座(4)：同步与死锁
上一篇：C#线程系列讲座(3)：线程池和文件下载服务器
虽然线程可以在一定程度上提高程序运行的效率，但也会产生一些副作用。让我们先看看如下的代码：
上面的程序的基本功能是使用Increment的Inc方法为n递增max，所不同的是，将在Main方法中启动30个线程同时执行Inc方法。在本例中max的值是10000（通过Increment的构造方法传入）。读者可以运行一下这个程序，正常的结果应该是300000，但通常不会得到这个结果，一般获得的结果都比300000小。其中的原因就是Inc方法中的
n++上，虽然从表面上看，n++只是一条简单的自增语言，但从底层分析，n++的IL代码如下：
ldsfld // 获得n的初始值，并压到方法栈中
ldc.i4.1 // 将1压到方法栈中
add // 从方法栈中弹出最顶端的两个值，相加，然后将结果保存在方法栈中
stfld // 从当前方法栈中弹出一个值，并更新类字段n
对于上面每一条IL语句是线程安全的，但是n++这条C#语句需要上面的四步才能完成，因此，n++这条语句并不是线程安全的。只要在执行stfld指令之前的任何一步由于其他线程获得CPU而中断，那么就会出现所谓的“脏”数据。
假设n的初始值为0，在thread1在执行完ldc.i4.1后被thread2中断（add指令并未执行），这时thread2获得的n的初始值仍然是0，假设thread2顺利执行完，那么这时n 的值已经是1了，当thread2执行完后，thread1继续执行add指令，并且thread1也顺利执行完，这时，在thread1中的执行结果n仍然是1。因此，这也就出现了调用两次n++，n仍然为1的情况。要解决这个问题的方法也很容易想到，就是让上述四条IL语句要不都不执行，要执行就都执行完，这有点事务处理的意思。
c语言同步的实现方式
c语言同步的实现方式
C语言中，同步（synchronization）是一种用来协调不同线程或进程之间执行顺序的技术。同步的实现方式可以通过以下几种机制：
1. 互斥锁（Mutex）：互斥锁是最常用的同步机制之一。它允许线程通过获取锁将自己排他地访问共享资源，其他线程必须等待锁释放后才能访问该资源。C语言提供了互斥锁相关的函数，如`pthread_mutex_init`、`pthread_mutex_lock`、
`pthread_mutex_unlock`等。
2. 信号量（Semaphore）：信号量是一种计数器，用于控制对资源的访问。当信号量的值大于零时，线程可以访问资源，访问后将信号量值减一；当信号量的值等于零时，线程必须等待。C语言提供了信号量相关的函数，如`sem_init`、`sem_wait`、
`sem_post`等。
3. 条件变量（Condition Variable）：条件变量用于在某些条件满足时才允许线程继续执行。线程可以通过条件变量等待某个条件的发生，当条件满足时，其他线程可以通过条件变量通知等待的线程继续执行。C语言提供了条件变量相关的函数，如
`pthread_cond_init`、`pthread_cond_wait`、
`pthread_cond_signal`等。
4. 屏障（Barrier）：屏障用于让多个线程在某个点上等待，直到所有线程都到达该点后才能继续执行。屏障可以用于同步多个线程的执行流程，以便它们在某个共享状态达到一致后再继续执行。C语言提供了屏障相关的函数，如`pthread_barrier_init`、`pthread_barrier_wait`等。
同步与互斥实现方法
同步与互斥实现方法
同步与互斥是并发编程中重要的概念，用于解决多个线程访问共享资
源的问题。同步是指多个线程按照一定的顺序执行，以避免产生竞争条件
和数据不一致的问题；而互斥是指多个线程不能同时访问一些共享资源，
而需要按照一定的顺序进行访问。下面将介绍几种常见的同步与互斥实现
方法。
1. 互斥锁（Mutex）
互斥锁是最常见和最基本的同步与互斥机制。互斥锁提供了两个操作，即上锁（lock）和解锁（unlock）。一个线程在执行临界区代码时会上锁，其他线程在发现互斥锁已经被锁定时，则需要等待。直到执行完临界区代
码后，线程解锁，其他线程才能继续执行。互斥锁的实现可以是通过硬件
原子指令或通过操作系统的系统调用进行。
2. 信号量（Semaphore）
信号量是另一种常见的同步与互斥机制。信号量有一个计数器，用来
表示资源的可用数量。一个线程在访问共享资源之前需要申请信号量，如
果信号量的计数器大于零，说明资源可用，线程可以继续执行；如果计数
器等于零，说明资源不可用，线程需要等待。当线程使用完共享资源后，
需要释放信号量，使得其他线程可以继续申请资源。
3. 读写锁（ReadWrite Lock）
读写锁是用于读写操作频繁且对数据一致性要求较高的情况下，提高
并发性能的一种同步与互斥机制。读写锁分为两种锁，即读锁和写锁。多
个线程可以同时持有读锁来读取共享资源，但是只有一个线程可以持有写
锁进行写操作。当存在写锁时，其他线程无法获得读锁或写锁。
4. 条件变量（Condition Variable）
条件变量用于等待一些条件的成立或通知一些条件的变化。线程可以
C中数据的同步加锁机制（精）
C#中数据的同步加锁机制收藏
对于数据库中，为数据或是访问数据的函数加锁是常见的，但是在C#中数据的同步加锁机制是什么样呢？
在多线程中，为了使数据保持一致性必须要对数据或是访问数据的函数加锁，在数据库中这是很常见的，但是在程序中由于大部分都是单线程的程序，所以没有加锁的必要，但是在多线程中，为了保持数据的同步，一定要加锁，好在Framework中已经为我们提供了三个加锁的机制，分别是Monitor类、Lock关键字和Mutex类。
其中Lock关键词用法比较简单，Monitor类和Lock的用法差不多。这两个都是锁定数据或是锁定被调用的函数。而Mutex则多用于锁定多线程间的同步调用。简单的说，Monitor和Lock多用于锁定被调用端，而Mutex则多用锁定调用端。
例如下面程序：由于这种程序都是毫秒级的，所以运行下面的程序可能在不同的机器上有不同的结果，在同一台机器上不同时刻运行也有不同的结果，我的测试环境为vs2005, windowsXp , CPU3.0 , 1 G monery。
程序中有两个线程thread1、thread2和一个TestFunc函数，TestFunc会打印出调用它的线程名和调用的时间(mm级的)，两个线程分别以30mm和100mm来调用TestFunc这个函数。TestFunc执行的时间为50mm。程序如下：
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
C语言技术中的信号量和读写锁操作详解
C语言技术中的信号量和读写锁操作详解
在多线程编程中，保证线程安全性是一个重要的问题。为了解决线程之间的资
源竞争和互斥访问，C语言提供了信号量和读写锁这两种机制。本文将详细介绍这两种技术的原理和使用方法。
一、信号量
信号量是一种用于线程同步和互斥的机制。它可以用来控制对共享资源的访问。在C语言中，我们可以使用信号量来解决多个线程同时访问共享资源的问题。
信号量的原理是基于计数器的。当一个线程想要访问共享资源时，它首先需要
检查信号量的值。如果信号量大于0，表示资源可用，线程可以继续执行并将信号
量的值减1。如果信号量等于0，表示资源不可用，线程需要等待，直到有其他线
程释放资源并将信号量的值加1。
在C语言中，我们可以使用`sem_init`函数初始化一个信号量，使用`sem_wait`
函数等待资源，使用`sem_post`函数释放资源。例如：
```c
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
sem_t semaphore;
void* thread_func(void* arg) {
sem_wait(&semaphore);
// 访问共享资源
sem_post(&semaphore);
return NULL;
}
int main() {
sem_init(&semaphore, 0, 1);
pthread_t tid1, tid2;
pthread_create(&tid1, NULL, thread_func, NULL);
c中的互斥锁
c中的互斥锁
在C 语言中，互斥锁（Mutex）是一种用于实现多线程同步的机制。互斥锁可以确保在同一时刻只有一个线程能够访问共享资源，从而避免了多线程并发访问共享资源时可能出现的竞争和数据不一致性问题。
互斥锁通常由操作系统提供，C 语言中的互斥锁可以通过操作系统提供的API 函数来实现。在使用互斥锁时，需要先创建一个互斥锁对象，然后在需要访问共享资源的代码片段前后分别调用互斥锁的加锁和解锁操作。
下面是一个简单的C 语言示例，演示了如何使用互斥锁来实现线程同步：
```c
#include <pthread.h>
#include <stdio.h>
pthread_mutex_t mutex; // 声明一个互斥锁变量
void* thread_function(void* arg) {
pthread_mutex_lock(&mutex); // 加锁
printf("Thread %lu is accessing shared resource...\n", pthread_self());
pthread_mutex_unlock(&mutex); // 解锁
return NULL;
}
int main() {
pthread_mutex_init(&mutex, NULL); // 初始化互斥锁
pthread_t threads[5];
for (int i = 0; i < 5; i++) {
pthread_create(&threads[i], NULL, thread_function, NULL);
死锁的简单例子c语言
死锁的简单例子c语言
死锁是指两个或多个进程在执行过程中因争夺资源而造成的一种互相等待的现象，导致各个进程都无法继续执行的情况。在C语言中，我们可以通过多线程来模拟死锁的简单例子。
下面是一个简单的C语言多线程死锁示例：
c.
#include 。
#include 。
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void thread1_function(void arg) {。
pthread_mutex_lock(&mutex1);
printf("Thread 1: Holding mutex 1...\n");
sleep(2);
printf("Thread 1: Waiting for mutex 2...\n");
pthread_mutex_lock(&mutex2);
printf("Thread 1: Holding mutex 2 and mutex 1...\n");
pthread_mutex_unlock(&mutex2);
pthread_mutex_unlock(&mutex1);
return NULL;
}。
void thread2_function(void arg) {。
pthread_mutex_lock(&mutex2);
printf("Thread 2: Holding mutex 2...\n");
sleep(2);
[C#]c#中数据的同步加锁机制的几种方法
![[C#]c#中数据的同步加锁机制的几种方法](https://img.taocdn.com/s3/m/0b17529ca1116c175f0e7cd184254b35eefd1a8e.png)
[C#]c#中数据的同步加锁机制的⼏种⽅法
⼀，锁定机制最简单的做法就是使⽤锁定关键字Lock。Lock关键字英⽂中就是锁的意思，顾名思义就是为操作加上⼀把锁。它的语法如下：
lock(lockObj)
{
//加锁的代码段，⼀般是操作共同资源的代码
}
⼆、同步⽅法（synchronized）
案例代码：
using System;
using pilerServices;
namespace App4Thread
{
class Program
{
private static int count = 0;
private static object myMutex = new object();
[MethodImpl(MethodImplOptions.Synchronized)]
public static void Main()
{
count++;
}
}
}
[MethodImpl(MethodImplOptions.Synchronized)]，该属性在⽅法调⽤期间锁定，阻⽌其他调⽤者调⽤。
命名空间：pilerServices
程序集：mscorlib（mscorlib.dll 中）
功能：pilerServices命名空间为编译器编写器提供使⽤托管代码在元数据中指定属性。
三
⾸先lock和Minitor有什么区别呢？
其实lock在IL代码中会被翻译成Monitor。也就是Monitor.Enter(obj)和Monitor.Exit(obj).
lock（obj）
{
}
等价为：
try
{
Monitor.Enter(obj)
c语言 互斥锁 信号量 条件变量
C语言中的互斥锁、信号量和条件变量
1. 介绍
C语言作为一种广泛应用的程序设计语言，其在多线程编程中也有着
重要的作用。在多线程编程中，为了保证线程之间的同步和互斥操作，常常需要使用互斥锁、信号量和条件变量等机制。本文将对C语言中
的互斥锁、信号量和条件变量进行介绍，以帮助读者更好地理解和应
用这些关键的多线程编程工具。
2. 互斥锁
互斥锁是一种常用的线程同步工具，用于保护共享资源不被多个线程
同时访问。在C语言中，我们可以使用pthread库中的mutex来实
现互斥锁。互斥锁的基本操作包括初始化、上锁和解锁。具体代码如下：
```c
#include <pthread.h>
pthread_mutex_t mutex;
int m本人n() {
pthread_mutex_init(mutex, NULL);
// 上锁
pthread_mutex_lock(mutex);
// 访问共享资源
// 解锁
pthread_mutex_unlock(mutex);
pthread_mutex_destroy(mutex);
return 0;
}
```
通过使用互斥锁，可以有效防止多个线程同时访问共享资源而造成的数据竞争问题，保证了程序的正确性和可靠性。
3. 信号量
信号量是另一种常用的线程同步工具，用于实现线程间的互斥和同步操作。在C语言中，我们可以使用pthread库中的semaphore来实现信号量。信号量的基本操作包括初始化、等待和释放。具体代码如下：
```c
#include <pthread.h>
实验四-同步与互斥-Linux实验报告
实验四-同步与互斥-Linux实验报告实验四同步与互斥 Linux 实验报告
一、实验目的
本次实验旨在深入理解操作系统中进程的同步与互斥概念，通过在Linux 环境下进行编程实践，掌握相关的实现方法和技术，提高对并发控制的认识和应用能力。
二、实验环境
操作系统：Linux（Ubuntu 2004）
编程语言：C 语言
开发工具：GCC 编译器
三、实验原理
（一）同步
同步是指多个进程在执行过程中需要按照一定的顺序协调工作，以确保它们之间的操作具有正确的逻辑关系。常见的同步机制包括信号量、条件变量等。
（二）互斥
互斥是指在同一时刻，只允许一个进程访问共享资源，以避免多个进程同时操作导致的数据不一致或错误。实现互斥的常见方法有互斥锁、临界区等。
四、实验内容
（一）使用信号量实现生产者消费者问题
1、问题描述
生产者不断生产产品并放入缓冲区，消费者从缓冲区取出产品进行消费。缓冲区大小有限，当缓冲区满时生产者停止生产，当缓冲区为空时消费者停止消费。
2、实现思路
创建一个信号量来表示缓冲区的可用空间数量，另一个信号量表示缓冲区中已有的产品数量。生产者在生产前检查可用空间信号量，消费者在消费前检查产品数量信号量。
3、代码实现
｀｀｀c
include ＜stdioh>
include ＜stdlibh>
include ＜pthreadh>
include ＜semaphoreh>
define BUFFER_SIZE 5
int bufferBUFFER_SIZE;
int in ＝ 0;
int out ＝ 0;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
读者写者问题
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
哲学家就餐
www.mobiletrain.org www.embedtrain.org
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
pthread互斥锁
• • • • 互斥锁属性pthread_mutexattr_t int pthread_mutexattr_init(pthread_mutexattr_t *attr); int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); 进程间共享属性
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
生产者
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
消费者
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
死锁
• 两个或多个进程在待一个事件 • 而这个事件需要某个处于等待的进程执行signal操作
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
生产消费者问题
• int full; /* 当前缓冲区内数据个数 */ • int empty; /* 当前缓冲区内空闲的个数 */ • int mutex; /* 提供对缓冲区的互斥操作，初始化为1 */
– P等Q离开监视器或等待另一条件变量
• signal and continue
– Q等P离开监视器或等待另一条件变量
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
监视器实现
• • • • 对每一个监视器使用一个信号量mutex,初始为1 想进入监视器进程需要先wait(mutex) 离开监视器的进程必须signal(mutex) 执行signal(mutex)的进程需要等待激 活的进程 • next(初始为0)，执行signal的进程可 以在next挂起 • next_count表示在next上挂起的进程数 • 每个外部函数里都要先等待mutex
千锋3G嵌入式移动互联网技术研发中心
监视器
• • • • • • • • • 信号量要求各个进程都符合使用规范 一个进程编程错误就会导致数据出错或死锁 一种抽象数据类型：私有数据和公共方法绑定 操作在监视器内部互斥 监视器保证进入的进程同时只能有一个处于活动状态 使用者提供条件变量用于同步 condition x x.wait 调用进程挂起 x.signal 恢复一个调用进程，若没有处于挂起的进程， 就什么效果都不发生，与信号量不同
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• 公共变量 counter 用来记录当前缓冲区中数据个数 • 生产者填充数据后，执行 counter ++
• 消费者取出数据后，执行 counter --
www.mobiletrain.org www.embedtrain.org
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
互斥锁
• • • • • • • 用锁来保护临界区 进入临界之前先申请锁 出临界区时释放锁 构造互斥锁很复杂 单处理机通过关中断实现 非抢占式内核使用 多处理机上关中断花时间
www.mobiletrain.org www.embedtrain.org
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
信号量
• 缺点：需要忙等，浪费CPU周期 • 优点：不需要上下文切换 • 消除忙等：
– 把等待信号量的进程转入挂起状态 – 等信号量大于零时唤醒 – 每个信号量有一个等待队列
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
Linux进程同步
• 提供了信号量和spinlock • 多处理机上是spinlock, 只能短期的持有 • 单处理机上使用信号量，通过使能内核抢占实现
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
Linux进程同步
• preempt_enable • preempt_disable • 处于内核态的任务持有锁时抢占是不安全的， preempt_count用于记录持有锁的数量
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
pthread同步
千锋3G嵌入式移动互联网技术研发中心
读者写者问题
• • • • • • • 多个并发的进程共享一个数据库 读者：只读数据库的进程 写者：更新数据库的进程 两个或多个读者同时访问，结果正确 一个写者和另外的进程去同时访问，出现混乱 变种1：读者不会因为有写者在等待而等待别的读者 变种2：写者优先，写者需要更新数据时尽快访问
硬件锁
• 使用交换原子操作构造锁
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
硬件锁
• 实现了有限等待的算法
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
信号量
• 锁使用复杂，多处理机上硬件实现困难 • 信号量是一个整数，有两个原子操作P和V • P(wait) V(increament)
千锋3G嵌入式移动互联网技术研发中心
Baidu Nhomakorabea
信号量
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
信号量实现
• • • • 回归到一个临界区问题 单处理机上关中断 多处理机上忙等(spinlock) 临界区很短
www.mobiletrain.org www.embedtrain.org
– 互斥 – 前进 – 有限等待
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
软件解决办法
• i 和 j 两个进程共享变量
• turn 表示允许进程进入临界区 • flag[t] 为真表示进程 t 准备进入 • 思想：两个进程互相谦让，先 谦让的先行，后让者后走 • 只是一个算法思路，无法保证 在不同架构机器上运行
– PTHREAD_PROCESS_PRIVATE – PTHREAD_PROCESS_SHARED
• int pthread_mutexattr_getpshared(const pthread_mutexattr_t * restrict attr, int *restrict pshared); • int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared);
千锋3G嵌入式移动互联网技术研发中心
临界区问题
• • • • • • • 临界区代码：修改公共变量，更新表格，写文件…... 一个进程进入临界区执行时 其它进程不能进入临界区 内核内部：打开文件列表 非抢占式内核不严重: winxp,win2000 抢占式内核问题严重:linux, solaries 解决办法应满足
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• • • • • 多个进程并发操作公共变量 公共变量的结果取决于执行顺序，出现竞争 并发时执行顺序不确定 解决办法：使得同时只有一个进程访问公共变量 进程同步或协调使得运行结果不会互相干扰
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• 两个进程并发，经打断和调度后，底层的指令乱序执行
• 执行前counter 的值是5 • 执行完成后，生产者进程出错: counter ++ 得到了4 • 若T4和T5的执行顺序调换一下，消费者进程出错： counter -- 得到了6
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
欢迎您到（千锋学院）来学 习!
同步与死锁
主讲老师：欧阳坚
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• 两个进程共享缓冲区 • 生产者进程只要发现缓冲区不满，就填充数据 • 消费者进程只要发现缓冲区内有数据，就向外取
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
监视器实现
• 条件变量的实现使用信号量 • 对每个信号量x提供信号量 x_sem和整数 x_count • x.wait x.signal
www.mobiletrain.org www.embedtrain.org
• • • • • 互斥锁 条件变量 读写锁 有些实现提供了信号量 有些实现提供了spinlock
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
pthread互斥锁
• pthread_mutex_t • 静态分配初始化PTHREAD_MUTEX_INITIALIZER • 动态分配初始化 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); • 动态销毁 int pthread_mutex_destroy(pthread_mutex_t *mutex);
千锋3G嵌入式移动互联网技术研发中心
硬件锁
• • • • 通过原子操作TestAndSet构造锁 把lock置成true，并返回原值 返回true说明锁被人持有 返回false同时得到锁
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
监视器
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
监视器
• 为保证监视器内部同时只能一个进程处于活动状态 • 假如进程P对 x 执行 signal时， 进程Q处于挂起状态等x • signal and wait
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
信号量
• • • • • 计数信号量：1----N 二进制信号量(互斥锁)： 0，1 二进制信号量可用于解决临界区问题 计数信号量用于解决多个进程访问数量有限的资源 解决同步问题，进程1的某语句先执行，进程程2后执行
www.mobiletrain.org www.embedtrain.org
千锋3G嵌入式移动互联网技术研发中心
pthread互斥锁
• 使用之前获得锁 int pthread_mutex_lock(pthread_mutex_t *mutex); • 不阻塞接口 int pthread_mutex_trylock(pthread_mutex_t *mutex); 正确返回0，否则返回EBUSY • 使用完释放互斥锁 int pthread_mutex_unlock(pthread_mutex_t *mutex); • 演示lockdemo