Linux系统的线程入门：基本概念、虚拟内存、Linux内核线程、线程应用

struct page {
    /* 原子标志，有些情况下会异步更新 */
    unsigned long flags;

    union {
        struct {
            /* 换出页列表，例如由 zone->lru_lock 保护的 active_list */
            struct list_head lru;

            /* 如果最低位为 0，则指向 inode 的 address_space，或为 null；
             * 如果页映射为匿名内存，最低位置位，且该指针指向 anon_vma 对象
             */
            struct address_space *mapping;

            /* 在映射内的偏移量 */
            pgoff_t index;

            /*
             * 由映射私有，不透明数据
             * - 如果设置了 pageprivate，通常用于 buffer_heads
             * - 如果设置了 pageswapcache，则用于 swp_entry_t
             * - 如果设置了 pg_buddy，则用于表示伙伴系统中的阶
             */
            unsigned long private;
        };

        struct { /* slab, slob and slub */
            union {
                struct list_head slab_list; /* 复用 lru */
                struct { /* partial pages */
                    struct page *next;
#ifdef config_64bit
                    int pages;    /* 剩余页数 */
                    int pobjects; /* 近似对象计数 */
#else
                    short int pages;
                    short int pobjects;
#endif
                };
            };
            struct kmem_cache *slab_cache; /* 不用于 slob */
            /* 双字边界对齐 */
            void *freelist;                /* 第一个空闲对象 */
            union {
                void *s_mem;               /* slab: 第一个对象 */
                unsigned long counters;    /* slub: 计数器 */
                struct { /* slub 专用 */
                    unsigned inuse : 16;   /* 已使用的对象数 */
                    unsigned objects : 15; /* 总对象数 */
                    unsigned frozen : 1;   /* 是否冻结 */
                };
            };
        };
        /* 其他可能的联合成员（如用于文件系统等） */
        ...
    };

    union {
        /* 内存管理子系统中映射的页表项计数，用于表示页是否已经映射，
         * 还用于限制逆向映射搜索 */
        atomic_t _mapcount;
        unsigned int page_type;
        unsigned int active; /* slab */
        int units;           /* slob */
    };

    /* 其余字段（如引用计数、私有用例等） */
    ...

#if defined(want_page_virtual)
    /* 内核虚拟地址（如果没有映射则为 null，即高端内存） */
    void *virtual;
#endif /* want_page_virtual */

    /* 后续可能还有其他成员，取决于内核配置 */
    ...
};

// #include <iostream>
// #include <thread>
// #include <unistd.h>

// // c++中的线程
// void hello()
// {
//     while(true)
//     {
//         std::cout << "我是新进程..., pid: " << getpid() << std::endl;
//         sleep(1);
//     }
// }


// int main()
// {
//     std::thread t(hello);

//     while(true)
//     {
//         std::cout << "我是主线程..., pid: " << getpid() << std::endl;
//         sleep(1);
//     }

//     t.join();
//     return 0;
// }

#include <iostream>
#include <pthread.h>
#include <unistd.h>

// linux中封装的线程 -- 其实linux是只有轻量级进程的概念的
void *hello(void *args)
{
    while(true)
    {
        const char *name = (const char*)args;
        std::cout << "我是新线程..., pid: " << getpid() << " name is : "<< name <<std::endl;
        sleep(1);
    }
}


int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, hello, (void*)"new-thread");

    while(true)
    {
        std::cout << "我是主线程..., pid: " << getpid() << std::endl;
        sleep(1);
    }

    return 0;
}

int g_val = 100;
int *p = nullptr;

void hello(const std::string &name) {
    printf("haha, i am common function!, %s\n", name.c_str());
    sleep(5);
}

void *threaddrun1(void *args)
{
    p = (int*)malloc(sizeof(int) * 10);
    std::string threadname = static_cast<const char*>(args);
    while(true)
    {
        printf("%s is running, g_val: %d, &g_val: %p\n", threadname.c_str(), g_val, &g_val);
        sleep(1);
        hello(threadname);
    }
}

void* threaddrun2(void *args)
{
    std::string threadname = static_cast<const char*>(args);
    while(true)
    {
        printf("%s is running, g_val: %d, &g_val: %p\n", threadname.c_str(), g_val, &g_val);
        sleep(1);
        g_val++;
        hello(threadname);
    }
}

int main()
{
    pthread_t t1, t2;
    pthread_create(&t1, nullptr, threaddrun1, (void*)"thread-1");
    pthread_create(&t2, nullptr, threaddrun2, (void*)"thread-2");
    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    return 0;
}