# 🔒 Transactions Sécurisées avec Threads 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 : 1. **Gestion multithreadée des transactions :** Chaque thread effectue un certain nombre de transactions aléatoires entre les comptes bancaires. 2. **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. 3. **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. 4. **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 : ```bash 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 : ```bash ./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 : ```plaintext ... 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 : ```bash make ``` ou ```bash gcc secured_transaction_threads.c -o secured_transaction_threads -pthread ``` Puis, on exécute : ```bash ./secured_transaction_threads 4 10 ``` ### Après l'exécution Voici une sortie typique du programme : ```plaintext 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 1. **Sécurité des Données :** Les mécanismes de verrouillage évitent toute corruption des données. 2. **Efficacité :** L'utilisation de threads optimise les performances par rapport à une version basée sur des processus. 3. **Simplicité :** Les threads partagent directement les ressources, éliminant le besoin de communication inter-processus.