vcpkg install openssl asio tinyxml2 fastcdr foonathan-memory --triplet x64-windows

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/foonathan_memory_vendor.git
cd foonathan_memory_vendor
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=i:/install/foonathan_memory_vendor ..
cmake --build . --config Release --target install

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/Fast-CDR.git
cd Fast-CDR
mkdir build && cd build
cmake -A x64 -DCMAKE_INSTALL_PREFIX=i:/install/fastcdr ..
cmake --build . --config Release --target install

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/Fast-DDS.git
cd Fast-DDS
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=i:/install/fastdds   ..
cmake --build . --config Release --target install

eprosima_find_thirdparty(Asio asio VERSION 1.13.0)

警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失

include '..\implib.inc'

; XYZLIBRARY.??4CXyz@@QAEAAV0@$$QAV0@@Z ord.1
implib XyzLibrary.dll, ??4CXyz@@QAEAAV0@$$QAV0@@Z
; XYZLIBRARY.??4CXyz@@QAEAAV0@ABV0@@Z ord.2
implib XyzLibrary.dll, ??4CXyz@@QAEAAV0@ABV0@@Z
; XYZLIBRARY.?Foo@CXyz@@QAEHH@Z ord.3
implib XyzLibrary.dll, ?Foo@CXyz@@QAEHH@Z
; XYZLIBRARY.GetXyz ord.4
implib XyzLibrary.dll, GetXyz
; XYZLIBRARY._GetXyz@0 ord.5
implib XyzLibrary.dll, _GetXyz@0
; XYZLIBRARY._XyzFoo@8 ord.6
implib XyzLibrary.dll, _XyzFoo@8
; XYZLIBRARY._XyzRelease@4 ord.7
implib XyzLibrary.dll, _XyzRelease@4

endlib

\bin\dll2def c:\windows\system32\kernel32.dll kernel32.def

\bin\fasm kernel32.def kernel32.lib

# 示例1

std::thread myThread ( thread_fun);
//函数形式为void thread_fun()
myThread.join();
//同一个函数可以代码复用，创建多个线程

# 示例2

std::thread myThread ( thread_fun(100));
myThread.join();
//函数形式为void thread_fun(int x)
//同一个函数可以代码复用，创建多个线程

# 示例3

std::thread (thread_fun,1).detach();
//直接创建线程，没有名字
//函数形式为void thread_fun(int x)

if (myThread.joinable()) foo.join();

#include <iostream>                // std::cout
#include <thread>                // std::thread
#include <mutex>                // std::mutex, std::unique_lock
#include <condition_variable>    // std::condition_variable

std::mutex mtx; // 全局互斥锁.
std::condition_variable cv; // 全局条件变量.
bool ready = false; // 全局标志位.

void do_print_id(int id)
{
	std::unique_lock <std::mutex> lck(mtx);
	while (!ready) // 如果标志位不为 true, 则等待...
		cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
	   // 线程被唤醒, 继续往下执行打印线程编号id.
	std::cout << "thread " << id << '\n';
}

void go()
{
	std::unique_lock <std::mutex> lck(mtx);
	ready = true; // 设置全局标志位为 true.
	cv.notify_all(); // 唤醒所有线程.
}

int main()
{
	std::thread threads[10];
	// spawn 10 threads:
	for (int i = 0; i < 10; ++i)
		threads[i] = std::thread(do_print_id, i);

	std::cout << "10 threads ready to race...\n";
	go(); // go!

	for (auto & th : threads)
		th.join();

	return 0;
}

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


class ThreadPool {
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(queueMutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<typename F, typename... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        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(); // 返回一个futur对象，result通过result.get()获取线程函数的返回值 如果线程函数没有执行完就会阻塞在result.get()
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }
            tasks.emplace([task]() { (*task)(); }); // Lambda函数是一种可调用对象 Lambda函数的语法为[捕获列表](参数列表) { 函数体 }。
        }
        condition.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};

// 示例任务函数
int  printHello(int num) {
    std::cout << "Hello from thread " << std::this_thread::get_id() << "! Num: " << num << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return num;
}

int main() {
    ThreadPool pool(4);

    std::vector<std::future<int>> results; 

    // 提交任务到线程池
    std::cout << "Enqueuing tasks..." << std::endl;
    for (int i = 0; i < 8; ++i) {
        results.push_back(pool.enqueue(printHello, i));
    }

    for (int i = 0; i < 8; ++i) {
        int num = results[i].get(); // 获取线程函数的返回值
        std::cout<< "获取到线程函数的返回值：" << num << std::endl;    // 获取线程函数的返回值  
    }

    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::seconds(5));

    return 0;
}

# 执行下面的指令
go env -w  GOPROXY=https://goproxy.cn,direct
 
# 输出确认一下，找到有 GOPROXY 的这一行，看是否有https://goproxy.cn,direct
go env

例如：

物理网卡名：eth0

创建的虚拟接口：

eth0.10 (对应VLAN 10)

eth0.20 (对应VLAN 20)

eth0.30 (对应VLAN 30)

eth0.10 -> 192.168.10.100/24 (VLAN 10的网关可能是 192.168.10.1)

eth0.20 -> 192.168.20.100/24 (VLAN 20的网关可能是 192.168.20.1)

eth0.30 -> 192.168.30.100/24 (VLAN 30的网关可能是 192.168.30.1)

打开日期和时间设置

找到Internet时间设置

选择NTP服务器并同步

打开注册表编辑器（regedit）。

导航到 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders\NtpClient。

找到名为 SpecialPollInterval 的DWORD值，双击打开，在“数值数据”中填入期望的同步间隔（以秒为单位）即可调整同步频率。

# 查看 chrony 依赖的包
apt-cache depends chrony

# 安装chrony，观察chrony依赖的包
sudo apt-get install chrony

# 下载 chrony及其依赖包
apt-get download chrony 

# 离线安装chrony
sudo dpkg -i *.deb

# 注释默认的 NTP 服务器pool，配置上级时间服务器
server 192.168.1.30 iburst

# 获取 chronyd 的PID
pgrep chronyd

# 直接终止（推荐）
kill <chronyd的PID>

# 强制终止（如果进程没有响应）
kill -9 <chronyd的PID>

# 启动 chronyd
sudo  chronyd

# 确保你的chrony服务器自身已经成功与上层服务器同步。可以通过 chronyc sources 命令检查，服务端需要先成功同步时间，才能为客户端提供同步服务, NTP服务器前设置 ^* 表示已与该服务区时钟同步。

chronyc sources -v
chronyc sourcestats -v

sudo chronyc -a makestep