Concorrenza in C++

#include <iostream>
#include <thread>
#include <vector>
using namespace std;

void saluta(int id) {
    cout << "Thread " << id << " dice ciao!\n";
}

void conta(int da, int a, int passo) {
    for (int i=da; i<=a; i+=passo)
        cout << "  " << i << " ";
    cout << "\n";
}

int main() {
    // Crea un thread
    thread t1(saluta, 1);
    thread t2(saluta, 2);

    // join: aspetta che il thread finisca (OBBLIGATORIO o usa detach)
    t1.join();
    t2.join();

    // Thread con lambda
    thread t3([](){ cout << "Lambda thread\n"; });
    t3.join();

    // Più thread in parallelo
    vector<thread> threads;
    for (int i=0; i<5; i++) {
        threads.emplace_back(conta, i*10, i*10+9, 1);
    }
    for (auto &t : threads) t.join();

    // hardware_concurrency: numero di core disponibili
    cout << "CPU cores: " << thread::hardware_concurrency() << "\n";

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
using namespace std;

// PROBLEMA: race condition senza mutex
int contatore_senza_mutex = 0;
void incrementa_unsafe() {
    for (int i=0; i<10000; i++) contatore_senza_mutex++;  // NON thread-safe!
}

// SOLUZIONE: mutex
mutex mtx;
int contatore = 0;

void incrementa_safe() {
    for (int i=0; i<10000; i++) {
        lock_guard<mutex> lock(mtx);  // RAII: acquisisce nel costruttore, rilascia nel distruttore
        contatore++;
    }
}

// unique_lock: più flessibile di lock_guard
void incrementa_unique() {
    for (int i=0; i<10000; i++) {
        unique_lock<mutex> lock(mtx);
        contatore++;
        // lock.unlock();  // Puoi rilasciare manualmente
        // lock.lock();    // E riaqcuisire
    }
}

// Classe thread-safe con lock interno
class ContatoreSicuro {
    mutable mutex mtx;
    int valore = 0;
public:
    void incrementa(int n=1) {
        lock_guard<mutex> l(mtx);
        valore += n;
    }
    int get() const {
        lock_guard<mutex> l(mtx);
        return valore;
    }
    void reset() {
        lock_guard<mutex> l(mtx);
        valore = 0;
    }
};

int main() {
    // Dimostra la race condition
    {
        vector<thread> ts;
        for (int i=0; i<4; i++) ts.emplace_back(incrementa_unsafe);
        for (auto &t : ts) t.join();
        cout << "Senza mutex: " << contatore_senza_mutex << " (dovrebbe essere 40000)\n";
    }

    // Con mutex
    {
        vector<thread> ts;
        for (int i=0; i<4; i++) ts.emplace_back(incrementa_safe);
        for (auto &t : ts) t.join();
        cout << "Con mutex: " << contatore << " (esattamente 40000)\n";
    }

    // Classe thread-safe
    ContatoreSicuro cs;
    {
        vector<thread> ts;
        for (int i=0; i<4; i++) ts.emplace_back([&cs](){ for(int j=0;j<10000;j++) cs.incrementa(); });
        for (auto &t : ts) t.join();
    }
    cout << "ContatoreSicuro: " << cs.get() << "\n";  // Sempre 40000

    return 0;
}

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>
using namespace std;

atomic<int> contatore_atomico{0};
atomic<bool> stop_flag{false};

void worker(int n) {
    for (int i=0; i<n; i++) {
        contatore_atomico++;        // Operazione atomica
        // contatore_atomico.fetch_add(1);  // Equivalente esplicito
    }
}

void timer_thread() {
    this_thread::sleep_for(100ms);
    stop_flag = true;  // Scrittura atomica
}

void loop_until_stop() {
    int count = 0;
    while (!stop_flag) {   // Lettura atomica
        count++;
    }
    cout << "Loop eseguito " << count << " volte\n";
}

int main() {
    vector<thread> ts;
    for (int i=0; i<4; i++) ts.emplace_back(worker, 10000);
    for (auto &t : ts) t.join();
    cout << "Atomico: " << contatore_atomico << "\n";  // Sempre 40000

    // Operazioni avanzate
    atomic<int> val{10};
    int vecchio = val.exchange(20);   // Scambia e restituisce il vecchio
    cout << "exchange: " << vecchio << " → " << val << "\n";

    // compare_and_swap (CAS) — fondamentale per strutture lock-free
    int expected = 20;
    bool successo = val.compare_exchange_strong(expected, 30);
    cout << "CAS " << (successo?"riuscito":"fallito") << " → " << val << "\n";

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <future>
#include <chrono>
using namespace std;

// ===== Producer-Consumer con condition_variable =====
queue<int> buffer;
mutex mtx;
condition_variable cv;
const int MAX_BUFFER = 10;
bool finito = false;

void producer(int n) {
    for (int i=0; i<n; i++) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock, []{ return buffer.size() < MAX_BUFFER; });  // Aspetta se pieno
        buffer.push(i);
        cout << "Prodotto: " << i << "\n";
        cv.notify_all();  // Notifica i consumer
    }
    {
        lock_guard<mutex> lock(mtx);
        finito = true;
    }
    cv.notify_all();
}

void consumer(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock, []{ return !buffer.empty() || finito; });

        if (buffer.empty()) break;  // Finito e buffer vuoto

        int val = buffer.front(); buffer.pop();
        lock.unlock();
        cv.notify_all();
        cout << "Consumer " << id << " consuma: " << val << "\n";
    }
}

// ===== std::async — esecuzione asincrona =====
int calcola_pesante(int n) {
    this_thread::sleep_for(chrono::milliseconds(100));  // Simula calcolo lento
    int sum = 0;
    for (int i=1; i<=n; i++) sum += i;
    return sum;
}

int main() {
    // async: lancia in background, ottieni il risultato con future::get()
    future<int> risultato = async(launch::async, calcola_pesante, 100);

    // Fai altro mentre calcola...
    cout << "Calcolo in corso...\n";
    this_thread::sleep_for(chrono::milliseconds(50));
    cout << "Ancora in attesa...\n";

    // get() blocca fino a quando il risultato è pronto
    cout << "Risultato: " << risultato.get() << "\n";

    // Lancia più calcoli in parallelo
    vector<future<int>> futures;
    for (int i=1; i<=4; i++)
        futures.push_back(async(launch::async, calcola_pesante, i*1000));

    int totale = 0;
    for (auto &f : futures) totale += f.get();
    cout << "Totale parallelo: " << totale << "\n";

    // promise/future: comunicazione tra thread
    promise<int> prom;
    future<int> fut = prom.get_future();

    thread t([&prom](){
        this_thread::sleep_for(50ms);
        prom.set_value(42);  // Invia il valore al future
    });

    cout << "Attendo il valore...\n";
    cout << "Ricevuto: " << fut.get() << "\n";
    t.join();

    return 0;
}