C++: مزامنة تعدد الخيوط

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

std::mutex mtx1, mtx2;

void thread1() {
	std::lock_guard<std::mutex> lock1(mtx1);
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	std::lock_guard<std::mutex> lock2(mtx2); // ينتظر mtx2
	std::cout << "Thread 1 done" << std::endl;
}

void thread2() {
	std::lock_guardstd::mutex lock2(mtx2);
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	std::lock_guardstd::mutex lock1(mtx1); // ينتظر mtx1
	std::cout << "Thread 2 done" << std::endl;
}

int main() {
	std::thread t1(thread1);
	std::thread t2(thread2);
	
	t1.join();
	t2.join();
	
	return 0;
}

Thread 1 done
Thread 2 done

void thread1() {
	std::lock_guardstd::mutex lock1(mtx1);
	std::lock_guardstd::mutex lock2(mtx2); // دائمًا mtx1 أولاً، ثم mtx2
	std::cout << "Thread 1 done" << std::endl;
}

void thread2() {
	std::lock_guardstd::mutex lock1(mtx1); // نفس ترتيب thread1
	std::lock_guardstd::mutex lock2(mtx2);
	std::cout << "Thread 2 done" << std::endl;
}

void safe_function() {
	std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock);
	std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock);
	std::lock(lock1, lock2); // قفل متزامن، يتجنب الجمود
	
	// ...
}

void safe_function() {
	std::scoped_lock lock(mtx1, mtx2); // يتجنب الجمود تلقائيًا
	
	// ...
}

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <unordered_map>

std::unordered_map<int, int> cache;
std::shared_mutex smtx;

int get(int key) {
	std::shared_lock<std::shared_mutex> lock(smtx); // قفل مشترك (قراءة)
	auto it = cache.find(key);
	if (it != cache.end()) {
		return it->second;
	}
	return -1;
}

void set(int key, int value) {
	std::unique_lock<std::shared_mutex> lock(smtx); // قفل حصري (كتابة)
	cache[key] = value;
}

int main() {
	// عدة خيوط يمكنها القراءة في وقت واحد؛ الكتابة حصرية
	return 0;
}

(خرج البرنامج)

#include <iostream>
#include <thread>
#include <vector>
#include <atomic>

std::atomic<int> counter(0); // متغير ذري

void increment() {
	for (int i = 0; i < 1000; i++) {
		counter++; // عملية ذرية، بدون قفل
	}
}

int main() {
	std::vector<std::thread> threads;
	for (int i = 0; i < 10; i++) {
		threads.emplace_back(increment);
	}
	
	for (auto& t : threads) {
		t.join();
	}
	
	std::cout << "Counter: " << counter << std::endl; // دائمًا 10000
	return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class ThreadPool {
private:
	std::vector<std::thread> workers;
	std::queue<std::function<void()>> tasks;
	std::mutex mtx;
	std::condition_variable cv;
	bool stop;

public:
	ThreadPool(size_t numThreads) : stop(false) {
		for (size_t i = 0; i < numThreads; i++) {
			workers.emplace_back([this] {
				while (true) {
					std::function<void()> task;
					{
						std::unique_lock<std::mutex> lock(mtx);
						cv.wait(lock, [this] {
							return stop || !tasks.empty();
						});
						
						if (stop && tasks.empty()) {
							return;
						}
						
						task = std::move(tasks.front());
						tasks.pop();
					}
					task();
				}
			});
		}
	}
	
	~ThreadPool() {
		{
			std::lock_guard<std::mutex> lock(mtx);
			stop = true;
		}
		cv.notify_all();
		for (auto& t : workers) {
			t.join();
		}
	}
	
	template<class F>
	void enqueue(F&& f) {
		{
			std::lock_guardstd::mutex lock(mtx);
			tasks.emplace(std::forward<F>(f));
		}
		cv.notify_one();
	}
};

int main() {
	ThreadPool pool(4); // إنشاء 4 خيوط
	
	for (int i = 0; i < 10; i++) {
		pool.enqueue([i] {
			std::cout << "Task " << i << " running" << std::endl;
		});
	}
	
	return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <algorithm>

void parallelSort(std::vector<int>& v, int left, int right) {
	if (left >= right) return;
	
	std::sort(v.begin() + left, v.begin() + right + 1);
}

int main() {
	std::vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
	
	// فرز متوازي بخيطين
	std::thread t1(parallelSort, std::ref(v), 0, v.size()/2);
	std::thread t2(parallelSort, std::ref(v), v.size()/2 + 1, v.size()-1);
	
	t1.join();
	t2.join();
	
	// دمج النصفين المرتبين
	std::inplace_merge(v.begin(), v.begin() + v.size()/2 + 1, v.end());
	
	for (int x : v) {
		std::cout << x << " ";
	}
	std::cout << std::endl;
	
	return 0;
}

3 1 4 1 5 9 2 6

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

int counter = 0;
std::mutex mtx;

void increment() {
    for (int i = 0; i < 1000; i++) {
        std::lock_guard<std::mutex> lock(mtx);
        counter++;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; i++) {
        threads.emplace_back(increment);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "counter = " << counter << std::endl;
    return 0;
}

counter = 10000