# 查看 pip 下载包缓存位置
pip cache dir

# 清理所有缓存
pip cache purge

# 查看 pip 安装包位置
pip show package_name

# venv
python -m venv .my-env
source .my-env/bin/activate

# pip安装 pytorch gpu 版本
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1  --index-url https://download.pytorch.org/whl/cu121
pip install transformers

# pip安装默认 pytorch cpu 版本
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cpu
pip install transformers

# 方括号 [] 的作用是指定额外的可选依赖包。
pip install "transformers[torch]"

import torch
print(torch.__version__)  # 应该显示 2.4.1+cu121
print(torch.cuda.is_available())  # 应该为 True（GPU版本）
print(torch.version.cuda)  # 应该显示 12.1

from transformers import pipeline

pipeline = pipeline(task="text-generation", model="Qwen/Qwen2.5-1.5B")
pipeline("the secret to baking a really good cake is ")

Script\activate

set HF_ENDPOINT=https://hf-mirror.com
echo %HF_ENDPOINT%

# 下载大模型默认保存位置：C:\Users\jack\.cache\huggingface\hub\
hf download Qwen/Qwen2.5-0.5B

# 自定义大模型保存位置
hf download Qwen/Qwen2.5-0.5B --local-dir ./LLM/Qwen/Qwen2.5-0.5B

# 自定义数据集保存位置
hf download --repo-type dataset --local-dir DataSet/glue glue

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)