Ce programme simule des transactions bancaires concurrentes avec un contrôle de verrouillage pour éviter les incohérences de données. L'utilisation de verrous permet de garantir que plusieurs processus n'accèdent pas simultanément aux mêmes comptes, empêchant ainsi les écritures corrompues et les conflits d'accès.
---
## 📋 Description du Programme
Le programme exécute plusieurs processus en parallèle, chacun effectuant un certain nombre de transactions aléatoires entre des comptes bancaires stockés dans un fichier de base de données. Cette version utilise des mécanismes de verrouillage pour éviter les problèmes d'accès concurrent.
### Fonctionnalités principales :
1.**Lecture/Écriture sécurisée de comptes** :
Les comptes sont lus et écrits dans un fichier (`accounts.db`). Chaque accès au fichier est protégé par un verrou exclusif, garantissant qu'un seul processus peut modifier un compte à la fois.
2.**Transactions sécurisées** :
Chaque processus effectue des transactions aléatoires entre deux comptes, avec un montant transféré d'un maximum de 20 % du solde du compte source.
3.**Contrôle des verrous** :
Utilisation de la fonction `lockf` pour verrouiller les sections du fichier correspondantes aux comptes pendant que les données sont lues ou écrites, garantissant une gestion correcte des accès concurrents.
4.**Calcul du solde total** :
Le solde total des comptes est calculé avant et après les transactions pour vérifier qu'il n'y a pas d'incohérences dues aux transactions.
---
## ⚙️ Compilation et Exécution
### Compilation
Utilisez le fichier `Makefile` pour compiler le programme :
```bash
make
```
Cela génère un exécutable nommé `secured_transaction`.
## 🛠️ Modifications par rapport à la version non sécurisée
### 1. **Verrouillage des comptes** :
Contrairement à la version non sécurisée, chaque opération de lecture et d'écriture sur un compte est protégée par un verrou exclusif. Ce verrou empêche d'autres processus de modifier le même compte pendant qu'une transaction est en cours, évitant ainsi les conflits d'accès.
### 2. **Gestion des Transactions** :
Les transactions sont réalisées avec un mécanisme de verrouillage, assurant qu'aucune écriture n'interfère avec une lecture ou une autre écriture simultanée. Ce processus garantit l'intégrité des soldes des comptes et évite les incohérences.
### 3. **Sécurité des données** :
Le programme utilise des appels `lockf` pour verrouiller la section du fichier contenant le compte avant toute lecture ou écriture, et pour libérer ce verrou une fois l'opération terminée. Cela permet de garantir que les données ne sont pas corrompues par des écritures concurrentes.
---
## 🛑 Problèmes et Limites
### 1. **Performance** :
Bien que le verrouillage évite les conflits d'écriture, il peut entraîner des ralentissements dans des environnements où de nombreux processus sont en concurrence pour accéder au fichier. En effet, l'attente du verrou par plusieurs processus peut entraîner des délais supplémentaires.
### 2. **Verrouillage global** :
Le programme utilise un verrouillage de type `lockf` pour verrouiller une section spécifique du fichier. Cependant, ce mécanisme peut ne pas être aussi efficace que des solutions plus complexes comme les bases de données transactionnelles.
---
## 📜 Exemple de Résultat
### Avant l'exécution
Le fichier [`accounts.db`](../Data/accounts.db) contient :
```plaintext
...
Diana 7145
Diego 8494
Dominic 4487
Dylan 1157
Easton 429
Eden 5737
Edward 3671
Elaina 4904
...
```
### Après l'exécution
Une possible sortie console pourrait être :
```plaintext
Solde total initial : 400000€
Transaction : Zuri -> Lane : 28€
Transaction : Alivia -> Kaiden : 8€
Transaction : Arianna -> Barrett : 5€
Transaction : Rosalie -> Connor : 1€
Transaction : Sara -> Arthur : 151€
Transaction : Jude -> Sadie : 45€
Solde total final : 4000000€
Tout les processus sont terminés !
```
---
Pour voir la version non sécurisée, consultez la section [🔓 Transactions Non Sécurisées](../Unsecured).
