🔄 C++并发编程¶

#include <iostream>
#include <thread>

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

int main() {
    std::thread t(hello);  // 创建线程

    std::cout << "Main thread: " << std::this_thread::get_id() << std::endl;
    std::cout << "Hardware concurrency: "
              << std::thread::hardware_concurrency() << std::endl;

    t.join();  // 等待线程完成
    return 0;
}

#include <iostream>
#include <thread>
#include <chrono>

void worker(int id, int ms) {
    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
    std::cout << "Worker " << id << " done\n";
}

int main() {
    // join: 主线程等待子线程完成
    std::thread t1(worker, 1, 100);
    t1.join();  // 阻塞直到 t1 完成

    // detach: 分离线程，后台独立运行
    std::thread t2(worker, 2, 50);
    t2.detach();  // t2 在后台运行，生命周期与主线程无关

    // ⚠️ 注意：线程对象销毁前必须 join 或 detach，否则 std::terminate
    // std::thread t3(worker, 3, 10);  // 未 join/detach → 程序终止

    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    return 0;
}

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

// 值传递
void by_value(int x) {
    x = 100;
}

// 引用传递 —— 必须使用 std::ref
void by_ref(int& x) {
    x = 100;
}

// 移动语义
void by_move(std::string s) {
    std::cout << "Moved string: " << s << std::endl;
}

// 成员函数
struct Task {
    void run(int id) {
        std::cout << "Task::run id=" << id << std::endl;
    }
};

int main() {
    // 值传递
    int a = 0;
    std::thread t1(by_value, a);
    t1.join();
    std::cout << "a after by_value: " << a << std::endl;  // 0（未改变）

    // 引用传递
    int b = 0;
    std::thread t2(by_ref, std::ref(b));  // ⚠️ 必须 std::ref
    t2.join();
    std::cout << "b after by_ref: " << b << std::endl;    // 100

    // 移动传递
    std::string str = "Hello Concurrency";
    std::thread t3(by_move, std::move(str));  // std::move 将左值转为右值引用，转移所有权
    t3.join();
    // str 已被移动，不可再用

    // 成员函数
    Task task;
    std::thread t4(&Task::run, &task, 42);
    t4.join();

    // Lambda
    int val = 10;
    std::thread t5([&val]() { val += 5; });
    t5.join();
    std::cout << "val after lambda: " << val << std::endl;  // 15

    return 0;
}

#include <iostream>
#include <thread>
#include <stop_token>

// C++20 jthread: 自动 join + 支持协作取消
void cancellable_work(std::stop_token stoken, int id) {
    while (!stoken.stop_requested()) {
        std::cout << "Worker " << id << " running...\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    std::cout << "Worker " << id << " stopped.\n";
}

int main() {
    std::jthread jt(cancellable_work, 1);
    std::this_thread::sleep_for(std::chrono::milliseconds(350));
    jt.request_stop();  // 请求停止
    // jt 析构时自动 join，无需手动调用
    return 0;
}

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

std::mutex mtx;  // std::mutex 互斥量，保护共享数据
int counter = 0;

void increment(int n) {
    for (int i = 0; i < n; ++i) {
        mtx.lock();
        ++counter;      // 临界区
        mtx.unlock();
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i)
        threads.emplace_back(increment, 100000);
    for (auto& t : threads) t.join();

    std::cout << "Counter: " << counter << std::endl;  // 400000（正确）
    return 0;
}

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

std::mutex mtx;
int shared_data = 0;

void safe_increment(int n) {
    for (int i = 0; i < n; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 构造时加锁
        ++shared_data;
        // 离开作用域自动解锁，即使抛异常也安全
    }
}

int main() {
    std::thread t1(safe_increment, 100000);
    std::thread t2(safe_increment, 100000);
    t1.join(); t2.join();
    std::cout << "Result: " << shared_data << std::endl;  // 200000
    return 0;
}

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

std::mutex mtx;

void flexible_locking() {
    // 延迟加锁
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
    // ... 做一些不需要锁的工作 ...
    lock.lock();    // 手动加锁
    std::cout << "Locked section\n";
    lock.unlock();  // 手动解锁

    // 尝试加锁（非阻塞）
    if (lock.try_lock()) {
        std::cout << "Got the lock\n";
        lock.unlock();
    }

    // 可以转移所有权
    std::unique_lock<std::mutex> lock2(std::move(lock));
}

// 避免死锁：std::lock 同时锁定多个互斥量
std::mutex mtx_a, mtx_b;

void no_deadlock() {
    std::unique_lock<std::mutex> la(mtx_a, std::defer_lock);
    std::unique_lock<std::mutex> lb(mtx_b, std::defer_lock);
    std::lock(la, lb);  // 原子地锁定两个互斥量，避免死锁
    std::cout << "Both locked safely\n";
}

// C++17: std::scoped_lock（更简洁的多锁方案）
void scoped_lock_demo() {
    std::scoped_lock lock(mtx_a, mtx_b);  // 同时锁定，自动解锁
    std::cout << "scoped_lock: both locked\n";
}

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>
#include <map>

class ThreadSafeMap {
    mutable std::shared_mutex rw_mutex_;
    std::map<std::string, int> data_;

public:
    // 读操作 —— 共享锁，多个读者可并发
    int read(const std::string& key) const {
        std::shared_lock<std::shared_mutex> lock(rw_mutex_);
        auto it = data_.find(key);
        return (it != data_.end()) ? it->second : -1;
    }

    // 写操作 —— 独占锁，互斥访问
    void write(const std::string& key, int value) {
        std::unique_lock<std::shared_mutex> lock(rw_mutex_);
        data_[key] = value;
    }

    size_t size() const {
        std::shared_lock<std::shared_mutex> lock(rw_mutex_);
        return data_.size();
    }
};

int main() {
    ThreadSafeMap tsm;

    // 多个写者
    std::vector<std::thread> writers;
    for (int i = 0; i < 5; ++i)
        writers.emplace_back([&tsm, i]() {
            tsm.write("key" + std::to_string(i), i * 10);
        });
    for (auto& t : writers) t.join();

    // 多个读者并发
    std::vector<std::thread> readers;
    for (int i = 0; i < 5; ++i)
        readers.emplace_back([&tsm, i]() {
            std::cout << "key" << i << " = " << tsm.read("key" + std::to_string(i)) << "\n";
        });
    for (auto& t : readers) t.join();

    return 0;
}

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

std::mutex mtx;
std::condition_variable cv;
std::queue<int> data_queue;
bool finished = false;

void producer() {
    for (int i = 0; i < 10; ++i) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            data_queue.push(i);
            std::cout << "Produced: " << i << "\n";
        }
        cv.notify_one();  // 通知一个等待的消费者
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    {
        std::lock_guard<std::mutex> lock(mtx);
        finished = true;
    }
    cv.notify_all();  // 通知所有消费者：生产结束
}

void consumer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // wait 接受谓词，防止虚假唤醒（spurious wakeup）
        cv.wait(lock, []{ return !data_queue.empty() || finished; });

        while (!data_queue.empty()) {
            int val = data_queue.front();
            data_queue.pop();
            std::cout << "Consumer " << id << " got: " << val << "\n";
        }

        if (finished && data_queue.empty()) break;
    }
}

int main() {
    std::thread prod(producer);
    std::thread cons1(consumer, 1);
    std::thread cons2(consumer, 2);

    prod.join();
    cons1.join();
    cons2.join();
    return 0;
}

#include <iostream>
#include <future>
#include <cmath>

double heavy_computation(double x) {
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    return std::sqrt(x * x + 1.0);
}

int main() {
    // std::launch::async   → 强制新线程执行
    // std::launch::deferred → 延迟执行（调用 get() 时才执行）
    // 默认 = async | deferred，由实现决定

    auto f1 = std::async(std::launch::async, heavy_computation, 3.0);  // std::async 异步执行任务，返回future
    auto f2 = std::async(std::launch::async, heavy_computation, 4.0);

    // 主线程可以做其他事...
    std::cout << "Waiting for results...\n";

    // get() 阻塞直到结果就绪
    double r1 = f1.get();
    double r2 = f2.get();

    std::cout << "Results: " << r1 << ", " << r2 << std::endl;
    return 0;
}

#include <iostream>
#include <thread>
#include <future>

void compute(std::promise<int> prom, int x) {
    try {
        if (x < 0) throw std::runtime_error("Negative input!");
        int result = x * x;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        prom.set_value(result);  // 设置结果
    } catch (...) {
        prom.set_exception(std::current_exception());  // 传递异常
    }
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    std::thread t(compute, std::move(prom), 7);

    try {
        int result = fut.get();  // 阻塞等待结果
        std::cout << "Result: " << result << std::endl;  // 49
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

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

int main() {
    auto shared_fut = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        return 42;
    }).share();  // 转为 shared_future

    // 多个线程可以同时 get()
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back([shared_fut, i]() {
            int val = shared_fut.get();
            std::cout << "Thread " << i << " got: " << val << "\n";
        });
    }
    for (auto& t : threads) t.join();
    return 0;
}

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

std::atomic<int> counter{0};

void atomic_increment(int n) {
    for (int i = 0; i < n; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);
        // 等价于 counter++ （默认 memory_order_seq_cst）
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i)
        threads.emplace_back(atomic_increment, 100000);
    for (auto& t : threads) t.join();

    std::cout << "Atomic counter: " << counter.load() << std::endl;  // 400000
    return 0;
}

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

std::atomic<int> value{0};

// 无锁递增——使用 CAS 循环
void cas_increment(int n) {
    for (int i = 0; i < n; ++i) {
        int expected = value.load(std::memory_order_relaxed);
        while (!value.compare_exchange_weak(
            expected, expected + 1,
            std::memory_order_release,
            std::memory_order_relaxed)) {
            // expected 自动更新为当前值，循环重试
        }
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i)
        threads.emplace_back(cas_increment, 100000);
    for (auto& t : threads) t.join();
    std::cout << "CAS result: " << value.load() << std::endl;  // 400000
    return 0;
}

#include <atomic>
#include <thread>
#include <iostream>
#include <cassert>

/*
 * C++ 内存序（Memory Order）—— 从宽松到严格
 *
 * memory_order_relaxed    - 仅保证原子性，不保证顺序
 * memory_order_acquire    - 本线程中，后续读写不会被重排到此操作之前
 * memory_order_release    - 本线程中，之前的读写不会被重排到此操作之后
 * memory_order_acq_rel    - acquire + release 的组合
 * memory_order_seq_cst    - 顺序一致性（默认，最严格，性能最低）
 *
 * 核心规则：
 * - release 写 与 acquire 读 配对，构成 happens-before 关系
 * - seq_cst 保证全局一致的操作顺序（所有线程看到相同的顺序）
 */

std::atomic<bool> ready{false};
std::atomic<int> data{0};

void writer() {
    data.store(42, std::memory_order_relaxed);    // ① 先写数据
    ready.store(true, std::memory_order_release);  // ② release 屏障
}

void reader() {
    while (!ready.load(std::memory_order_acquire)) {}  // ③ acquire 屏障
    int value = data.load(std::memory_order_relaxed);   // ④ 一定能看到 42
    assert(value == 42);  // 由 ②→③ 的 happens-before 保证
    std::cout << "Read value: " << value << std::endl;
}

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

#include <atomic>
#include <thread>
#include <iostream>
#ifdef _MSC_VER
#include <intrin.h>   // MSVC: _mm_pause()
#endif

class SpinLock {
    std::atomic_flag flag_{};  // C++20: 默认初始化为 clear（ATOMIC_FLAG_INIT 已弃用）
public:
    void lock() {
        while (flag_.test_and_set(std::memory_order_acquire)) {
            // 自旋等待（pause 指令降低 CPU 功耗与总线争用）
            #if defined(__x86_64__) || defined(__i386__)
            __builtin_ia32_pause();       // GCC / Clang
            #elif defined(_M_X64) || defined(_M_IX86)
            _mm_pause();                  // MSVC
            #endif
        }
    }
    void unlock() {
        flag_.clear(std::memory_order_release);
    }
};

SpinLock spin;
int shared_counter = 0;

void spin_increment(int n) {
    for (int i = 0; i < n; ++i) {
        spin.lock();
        ++shared_counter;
        spin.unlock();
    }
}

int main() {
    std::thread t1(spin_increment, 100000);
    std::thread t2(spin_increment, 100000);
    t1.join(); t2.join();
    std::cout << "Spinlock counter: " << shared_counter << std::endl;
    return 0;
}

#include <coroutine>
#include <iostream>
#include <optional>

template<typename T>
struct Generator {
    struct promise_type {
        T current_value;

        Generator get_return_object() {
            return Generator{
                std::coroutine_handle<promise_type>::from_promise(*this)
            };
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        std::suspend_always yield_value(T value) {
            current_value = value;
            return {};
        }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle_;

    Generator(std::coroutine_handle<promise_type> h) : handle_(h) {}
    ~Generator() { if (handle_) handle_.destroy(); }

    // 禁止拷贝
    Generator(const Generator&) = delete;
    Generator& operator=(const Generator&) = delete;
    Generator(Generator&& other) : handle_(other.handle_) { other.handle_ = nullptr; }

    std::optional<T> next() {
        if (!handle_ || handle_.done()) return std::nullopt;
        handle_.resume();
        if (handle_.done()) return std::nullopt;
        return handle_.promise().current_value;
    }
};

// 使用 co_yield 生成斐波那契数列
Generator<uint64_t> fibonacci() {
    uint64_t a = 0, b = 1;
    while (true) {
        co_yield a;
        auto next = a + b;
        a = b;
        b = next;
    }
}

int main() {
    auto fib = fibonacci();
    for (int i = 0; i < 15; ++i) {
        auto val = fib.next();
        if (val) std::cout << *val << " ";
    }
    std::cout << std::endl;
    // 输出: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    return 0;
}

#include <coroutine>
#include <iostream>

struct Task {
    struct promise_type {
        int result_value;
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_value(int v) { result_value = v; }
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle_;
    Task(std::coroutine_handle<promise_type> h) : handle_(h) {}
    ~Task() { if (handle_) handle_.destroy(); }

    int get_result() { return handle_.promise().result_value; }
};

Task compute_async(int x) {
    // 在实际应用中，co_await 可以等待 I/O 完成
    std::cout << "Computing " << x << " * " << x << "...\n";
    co_return x * x;
}

int main() {
    Task t = compute_async(7);
    std::cout << "Result: " << t.get_result() << std::endl;  // 49
    return 0;
}

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

class ThreadPool {
public:
    explicit ThreadPool(size_t num_threads) : stop_(false) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers_.emplace_back([this]() {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex_);
                        condition_.wait(lock, [this]{
                            return stop_ || !tasks_.empty();
                        });
                        if (stop_ && tasks_.empty()) return;
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();
                }
            });
        }
    }

    // 提交任务，返回 future
    template<typename F, typename... Args>
    auto submit(F&& f, Args&&... args)
        -> std::future<decltype(f(args...))>
    {
        using return_type = decltype(f(args...));
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        std::future<return_type> result = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            if (stop_) throw std::runtime_error("submit on stopped pool");
            tasks_.emplace([task]() { (*task)(); });
        }
        condition_.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            stop_ = true;
        }
        condition_.notify_all();
        for (auto& worker : workers_)
            worker.join();
    }

private:
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    bool stop_;
};

int main() {
    ThreadPool pool(4);

    // 提交多个任务
    std::vector<std::future<int>> results;
    for (int i = 0; i < 10; ++i) {
        results.push_back(pool.submit([i]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            return i * i;
        }));
    }

    for (auto& fut : results)
        std::cout << fut.get() << " ";
    std::cout << std::endl;
    // 输出: 0 1 4 9 16 25 36 49 64 81
    return 0;
}

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

template<typename T>
class BoundedQueue {
public:
    explicit BoundedQueue(size_t capacity) : capacity_(capacity) {}

    void push(T item) {
        std::unique_lock<std::mutex> lock(mtx_);
        not_full_.wait(lock, [this]{ return queue_.size() < capacity_; });
        queue_.push(std::move(item));
        not_empty_.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mtx_);
        not_empty_.wait(lock, [this]{ return !queue_.empty(); });
        T item = std::move(queue_.front());
        queue_.pop();
        not_full_.notify_one();
        return item;
    }

    // 带超时的出队
    std::optional<T> try_pop(std::chrono::milliseconds timeout) {
        std::unique_lock<std::mutex> lock(mtx_);
        if (!not_empty_.wait_for(lock, timeout, [this]{ return !queue_.empty(); }))
            return std::nullopt;
        T item = std::move(queue_.front());
        queue_.pop();
        not_full_.notify_one();
        return item;
    }

private:
    std::queue<T> queue_;
    size_t capacity_;
    std::mutex mtx_;
    std::condition_variable not_full_;
    std::condition_variable not_empty_;
};

int main() {
    BoundedQueue<int> bq(5);  // 容量为 5

    // 3 个生产者
    std::vector<std::thread> producers;
    for (int p = 0; p < 3; ++p) {
        producers.emplace_back([&bq, p]() {
            for (int i = 0; i < 5; ++i) {
                int val = p * 100 + i;
                bq.push(val);
                std::cout << "P" << p << " -> " << val << "\n";
            }
        });
    }

    // 2 个消费者
    std::vector<std::thread> consumers;
    for (int c = 0; c < 2; ++c) {
        consumers.emplace_back([&bq, c]() {
            for (int i = 0; i < 7; ++i) {  // 每个消费者取 7 个
                int val = bq.pop();
                std::cout << "  C" << c << " <- " << val << "\n";
            }
        });
    }

    // 还有 1 个元素由主线程消费
    for (auto& t : producers) t.join();
    for (auto& t : consumers) t.join();
    int last = bq.pop();
    std::cout << "Main <- " << last << "\n";

    return 0;
}

#include <atomic>
#include <memory>
#include <iostream>

template<typename T>
class LockFreeStack {
    struct Node {
        T data;
        Node* next;
        Node(T val) : data(std::move(val)), next(nullptr) {}
    };

    std::atomic<Node*> head_{nullptr};

public:
    void push(T val) {
        Node* new_node = new Node(std::move(val));
        new_node->next = head_.load(std::memory_order_relaxed);
        // CAS 循环：如果 head 未变，则更新成功
        while (!head_.compare_exchange_weak(
            new_node->next, new_node,
            std::memory_order_release,
            std::memory_order_relaxed)) {}
    }

    // ⚠️ ABA 问题 & Use-After-Free 风险：
    //   1. ABA：线程A读到 old_head=X，线程B pop X 再 push 新节点到同一地址X，
    //      线程A的 CAS 看到 head 仍是 X 便成功，但 X->next 已失效 → 数据结构损坏。
    //   2. Use-After-Free：线程A读到 old_head->next 之前，线程B 可能已 delete old_head。
    //   生产环境解决方案：Hazard Pointers、Epoch-Based Reclamation 或
    //   std::atomic<std::shared_ptr<Node>>（C++20）。
    bool pop(T& result) {
        Node* old_head = head_.load(std::memory_order_acquire);
        while (old_head && !head_.compare_exchange_weak(
            old_head, old_head->next,
            std::memory_order_acq_rel,
            std::memory_order_acquire)) {}
        if (!old_head) return false;
        result = std::move(old_head->data);
        delete old_head;  // 简化处理，生产环境需用 hazard pointer 或 RCU
        return true;
    }

    ~LockFreeStack() {
        T dummy;
        while (pop(dummy)) {}
    }
};

int main() {
    LockFreeStack<int> stack;
    stack.push(1);
    stack.push(2);
    stack.push(3);

    int val;
    while (stack.pop(val))
        std::cout << val << " ";  // 3 2 1
    std::cout << std::endl;
    return 0;
}

// 伪共享示例与解决
#include <atomic>
#include <thread>
#include <iostream>
#include <chrono>

// ❌ 有伪共享：两个原子变量可能在同一缓存行
struct BadAlign {
    std::atomic<int> a{0};
    std::atomic<int> b{0};
};

// ✅ 避免伪共享：强制对齐到不同缓存行
struct GoodAlign {
    alignas(64) std::atomic<int> a{0};
    alignas(64) std::atomic<int> b{0};
};

template<typename T>
void benchmark(const char* name) {
    T data;
    auto start = std::chrono::high_resolution_clock::now();
    std::thread t1([&]{ for(int i=0;i<10000000;++i) data.a.fetch_add(1, std::memory_order_relaxed); });
    std::thread t2([&]{ for(int i=0;i<10000000;++i) data.b.fetch_add(1, std::memory_order_relaxed); });
    t1.join(); t2.join();
    auto end = std::chrono::high_resolution_clock::now();
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    std::cout << name << ": " << ms << " ms\n";
}

int main() {
    benchmark<BadAlign>("BadAlign (false sharing)");
    benchmark<GoodAlign>("GoodAlign (no false sharing)");
    return 0;
}