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 :

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.
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.
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.
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 :

make

Cela génère un exécutable nommé secured_transaction.

Exécution

Exécutez le programme en spécifiant :

Le nombre de processus à lancer.
Le nombre de transactions par processus.

Exemple :

./secured_transaction 30 50

Ici, 30 processus seront lancés, chacun effectuant 50 transactions.

🛠️ 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 contient :

...
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 :

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.