char greetings[] = "Hello World!";
printf("%c", greetings[0]);

// gcc -o pthread_example pthread_example.c -lpthread
// ./pthread_example
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

#define NUM_THREADS 3  // Define the number of threads you want to create

// Define the function that each thread will execute
void *print_message(void *thread_id) {
    long tid = (long) thread_id;
    printf("Hello from thread %ld\n", tid);
    pthread_exit(NULL);  // End the thread
}

int main() {
    pthread_t threads[NUM_THREADS];  // Array to hold thread identifiers
    int rc;  // Return code from pthread functions
    long t;

    // Create NUM_THREADS threads
    for (t = 0; t < NUM_THREADS; t++) {
        printf("Creating thread %ld\n", t);
        rc = pthread_create(&threads[t], NULL, print_message, (void *) t);
        if (rc) {
            // If there is an error, print the error code and exit
            printf("Error: pthread_create failed with code %d\n", rc);
            exit(-1);
        }
    }

    // Wait for all threads to complete
    for (t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL);
    }

    printf("All threads completed.\n");
    return 0;
}

#include <iostream>
#include <thread>

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

int main() {
    std::thread t(threadFunction); // Create a new thread
    t.join(); // Wait for the thread to complete
    return 0;
}

from concurrent.futures import ProcessPoolExecutor
import random
import time

def square_number(number):
    """Function that squares a given number"""
    time.sleep(1)  # Simulating a time-consuming operation
    return number ** 2

def main():
    # List of numbers to square
    numbers = [random.randint(1, 10) for _ in range(10)]

    # Create a ProcessPoolExecutor with 4 worker processes
    with ProcessPoolExecutor(max_workers=4) as executor:
        # Submit tasks to the executor and collect Future objects
        future_to_number = {executor.submit(square_number, num): num for num in numbers}

        # Retrieve results as they complete
        for future in future_to_number:
            number = future_to_number[future]
            try:
                # Get the result of the future
                result = future.result()
                print(f"The square of {number} is {result}")
            except Exception as exc:
                print(f"Generated an exception: {exc}")

if __name__ == '__main__':
    main()

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

public class ParallelismExample {
    public static void main(String[] args) {
        // Create a list of integers
        List<Integer> numbers = new ArrayList<>();
        Random random = new Random();

        // Populate the list with random numbers
        for (int i = 0; i < 10000; i++) {
            numbers.add(random.nextInt(100));
        }

        // Use parallelStream() to create a parallel stream from the list
        List<Integer> filteredNumbers = numbers.parallelStream()
                // Filter the list to include only even numbers
                .filter(number -> number % 2 == 0)
                // Sort the filtered numbers in descending order
                .sorted((a, b) -> b - a)
                // Collect the results into a list
                .collect(Collectors.toList());

        // Print the filtered and sorted list
        System.out.println("Filtered and sorted numbers (only even numbers):");
        System.out.println(filteredNumbers);
    }
}

import Foundation

// Define a function to be executed in a separate thread
func performExpensiveTask() {
    // Simulate an expensive task
    sleep(5)
    print("Expensive task completed on thread: \(Thread.current)")
}

// Create a new thread and start the expensive task
let newThread = Thread {
    performExpensiveTask()
}

// Start the new thread
newThread.start()

// Print a message on the main thread
print("Main thread continues running...")

import Foundation

// Define a function to simulate a time-consuming task
func performTask(id: Int) {
    print("Task \(id) started")
    // Simulate some work using a sleep
    sleep(UInt32(id))
    print("Task \(id) completed")
}

// Define the main function
func main() {
    // Create a concurrent queue using GCD
    let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
    
    // Dispatch tasks to the concurrent queue
    for i in 1...5 {
        concurrentQueue.async {
            performTask(id: i)
        }
    }
    
    // Add a small delay to allow tasks to complete before the program exits
    // In a real-world scenario, you may want to use DispatchGroup or other synchronization primitives
    Thread.sleep(forTimeInterval: 6)
}

// Call the main function
main()