MiniProjet2/SecuredThread/README.md

# 🔒 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.