Ce programme simule des transactions bancaires concurrentes en utilisant des threads, une approche plus efficace et légère que les processus. Les threads exécutent des transactions entre comptes bancaires, tout en partageant les ressources de manière optimale grâce à des mécanismes de verrouillage qui garantissent l'intégrité des données.

📋 Description du Programme

Le programme utilise des threads pour gérer plusieurs transactions simultanées entre comptes bancaires stockés dans un fichier de base de données. Contrairement à une version basée sur des processus, cette approche utilise un espace mémoire partagé, réduisant les coûts de communication et augmentant la performance.

Fonctionnalités principales :

Gestion multithreadée des transactions : Chaque thread effectue un certain nombre de transactions aléatoires entre les comptes bancaires.
Synchronisation avec Mutex : Des verrous sont utilisés pour garantir des accès sécurisés au fichier contenant les comptes, empêchant les corruptions de données.
Optimisation des ressources : Les threads partagent la mémoire et les ressources du processus parent, réduisant les coûts liés à la création et à la gestion des entités concurrentes.
Calcul du solde total : Le programme vérifie l'intégrité des données en calculant le solde total avant et après les 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_threads.

Exécution

Exécutez le programme en spécifiant :

Le nombre de threads à lancer.
Le nombre de transactions par thread.

Exemple :

./secured_transaction_threads 4 10

Ici, 4 threads seront créés, chacun effectuant 10 transactions.

🛡️ Pourquoi utiliser des Threads ?

1. Partage de Mémoire :

Les threads partagent l'espace mémoire du processus parent, ce qui permet un accès rapide et direct aux données.
Dans cette application, tous les threads peuvent accéder et modifier les comptes bancaires sans mécanismes complexes de communication inter-processus.

2. Performance Optimisée :

Les threads sont plus légers que les processus. La création d'un thread est moins coûteuse en temps et en ressources.
La commutation de contexte entre threads est plus rapide que celle entre processus, ce qui améliore les performances globales.

3. Synchronisation Facile :

Grâce aux primitives comme les mutex, les threads peuvent synchroniser leurs accès aux ressources partagées de manière efficace.
Ici, un mutex est utilisé pour s'assurer qu'un seul thread à la fois modifie le fichier des comptes bancaires.

4. Adapté au Parallélisme :

Les threads permettent de tirer parti des architectures multicœurs, ce qui accélère les transactions simultanées.

🛑 Problèmes Résolus

1. Incohérences de Données :

Les mécanismes de verrouillage garantissent que chaque transaction est exécutée de manière atomique. Cela empêche les conflits d'accès entre plusieurs threads.

2. Solde Final Correct :

Grâce à la synchronisation, le solde total des comptes reste cohérent avant et après les transactions.

3. Gestion des Transactions :

Chaque transaction est complètement exécutée avant qu'une autre ne puisse accéder aux mêmes données.

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

Compilation et exécution

On compile le programme avec :

make

gcc secured_transaction_threads.c -o secured_transaction_threads -pthread

Puis, on exécute :

./secured_transaction_threads 4 10

Après l'exécution

Voici une sortie typique du programme :

Solde total initial : 400000€
...
Transaction : Alivia -> Kaiden : 14€
Transaction : Arianna -> Barrett : 3€
Transaction : Rosalie -> Connor : 1€
Transaction : Sara -> Arthur : 190€
Transaction : Jude -> Sadie : 41€
...
Solde total final : 400000€
Tout est terminé sans incohérences !

🚀 Points Forts de cette Version

Sécurité des Données : Les mécanismes de verrouillage évitent toute corruption des données.
Efficacité : L'utilisation de threads optimise les performances par rapport à une version basée sur des processus.
Simplicité : Les threads partagent directement les ressources, éliminant le besoin de communication inter-processus.