What are some examples of thread safety in C++ and Java?

What are some examples of thread safety in C++ and Java?

Thread safety ensures that shared data is accessed by multiple threads without conflict. In C++, you can use mutexes, while in Java, synchronized blocks are common.

Can you give me a specific example of using a mutex in C++?

Sure! Here's a simple example:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_data = 0;

void increment() {
    mtx.lock();
    ++shared_data;
    mtx.unlock();
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << shared_data << std::endl;
}

This code safely increments shared_data using a mutex.

What about Java? Can you show me a synchronized block example?

Absolutely! Here's a Java example using synchronized blocks:

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> counter.increment());
        Thread t2 = new Thread(() -> counter.increment());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Count: " + counter.getCount());
    }
}

This ensures that the increment method is thread-safe.