C++: أساسيات تعدد الخيوط

#include <iostream>
#include <thread>

void hello() {
	std::cout << "Hello from thread!" << std::endl;
}

int main() {
	std::thread t(hello); // إنشاء خيط
	t.join(); // انتظار انتهاء الخيط
	
	std::cout << "Main thread ends" << std::endl;
	return 0;
}

Main thread: starting
Main thread: waiting for child thread
Child thread: Hello from thread
Main thread: ended

Hello from thread!
Main thread ends

#include <iostream>
### ▶ مثال 2: عرض البرمجة متعددة الخيوط (الصعوبة ⭐)

#include <thread>
#include <chrono>

void worker(int id) {
	for (int i = 0; i < 3; i++) {
		std::cout << "Worker " << id << " working..." << std::endl;
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}
}

int main() {
	std::thread t1(worker, 1);
	std::thread t2(worker, 2);
	
	t1.join(); // انتظار انتهاء t1
	t2.join(); // انتظار انتهاء t2
	
	std::cout << "All workers done" << std::endl;
	return 0;
}

#include <iostream>
#include <thread>
#include <string>

void printMessage(std::string msg, int count) {
	for (int i = 0; i < count; i++) {
		std::cout << msg << std::endl;
	}
}

int main() {
	std::thread t(printMessage, "Hello", 3);
	t.join();
	
	return 0;
}

#include <iostream>
#include <thread>
#include <functional>

void increment(int& x) {
	x++;
}

int main() {
	int counter = 0;
	std::thread t(increment, std::ref(counter));
	t.join();
	
	std::cout << "Counter: " << counter << std::endl; // الخرج: 1
	return 0;
}

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

int counter = 0;

void increment() {
	for (int i = 0; i < 1000; i++) {
		counter++; // عدة خيوط تعدّل في وقت واحد، النتيجة غير مؤكدة
	}
}

int main() {
	std::vectorstd::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 <mutex>

int counter = 0;
std::mutex mtx;

void increment() {
	for (int i = 0; i < 1000; i++) {
		mtx.lock(); // القفل
		counter++;
		mtx.unlock(); // فتح القفل
	}
}

int main() {
	std::vectorstd::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;
}

void increment() {
	for (int i = 0; i < 1000; i++) {
		std::lock_guardstd::mutex lock(mtx); // يقفل عند الإنشاء، يفتح عند التدمير
		counter++;
	} // فتح تلقائي
}

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

std::queueint q;
std::mutex mtx;
std::condition_variable cv;

void producer() {
	for (int i = 0; i < 10; i++) {
		std::lock_guardstd::mutex lock(mtx);
		q.push(i);
		std::cout << "Produced: " << i << std::endl;
		cv.notify_one(); // إخطار المستهلك
	}
}

void consumer() {
	for (int i = 0; i < 10; i++) {
		std::unique_lockstd::mutex lock(mtx);
		cv.wait(lock, { return !q.empty(); }); // انتظر حتى لا يكون الطابور فارغًا
		
		int value = q.front();
		q.pop();
		std::cout << "Consumed: " << value << std::endl;
	}
}

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

Produced: 
Consumed: 

#include <iostream>
#include <future>

int calculate(int x) {
	return x * x;
}

int main() {
	std::futureint result = std::async(calculate, 10);
	std::cout << "Result: " << result.get() << std::endl; // الخرج: 100
	
	return 0;
}

#include <iostream>
#include <thread>

void printNumbers(int start, int end) {
    for (int i = start; i <= end; i++) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::thread t1(printNumbers, 1, 5);
    std::thread t2(printNumbers, 10, 15);

    t1.join();
    t2.join();

    return 0;
}

1 10 2 11 3 12 4 13 5 14 15