【Linux】第四十二站：线程局部存储与线程分离

最新推荐文章于 2024-09-14 19:34:20 发布
最新推荐文章于 2024-09-14 19:34:20 发布
阅读量1.3k 收藏 24
点赞数 36
分类专栏： 【Linux】 文章标签： linux 算法 c++ 前端 开发语言 数据结构 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jhdhdhehej/article/details/136601814
版权

一、线程的局部存储

1.实现多线程

如果我们想创建多线程，我们可以用下面的代码类似去实现

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 10

struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    threadData *td = static_cast<threadData*>(args);

    int i = 0;
    while(i < 10)
    {
        cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) << ", threadname : " << td->threadname << endl;
        sleep(1);
        i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
        sleep(1);
    }
    for(int i = 0; i < tids.size(); i++)
    {
        pthread_join(tids[i], nullptr);
    }

    return 0;
}

运行结果如下图所示

image-20240229203441892

在这里我们就发现了一个问题：

所有的线程，执行的都是这个函数

一旦一个线程修改了数据，其他线程看到这个数据都会被修改

2.线程有独立的栈结构

当代码如下的时候

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3

struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    int test_i = 0;
    threadData *td = static_cast<threadData*>(args);
    int i = 0;
    while(i < 10)
    {
        cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) 
        << ", threadname : " << td->threadname 
        << ", test_i: " << test_i << ", &test_i: " << toHex((pthread_t)&test_i) << endl;

        sleep(1);
        i++;
        test_i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
        sleep(1);
    }
    for(int i = 0; i < tids.size(); i++)
    {
        pthread_join(tids[i], nullptr);
    }

    return 0;
}

运行结果为：

image-20240229204957681

我们可以看到每一个线程的test_i都会独立的增长，并且每个test_i的地址都不一样

这是因为每一个线程都会有自己独立的栈结构。

3.线程之间没有秘密

那么如果我们主线程就想要访问上面线程1的变量，我们可以做到吗？当然可以做到，因为它也在同一个地址空间中。

就比如下面的代码就可以实现主线程访问线程2的变量

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3

int *p = NULL;

struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    int test_i = 0;
    threadData *td = static_cast<threadData*>(args);
    if(td->threadname == "thread-2")
    {
        p = &test_i;
    }
    int i = 0;
    while(i < 10)
    {
        cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) 
        << ", threadname : " << td->threadname 
        << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;

        sleep(1);
        i++;
        test_i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
    }
    sleep(1); //确保复制成功
    cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   

    for(int i = 0; i < tids.size(); i++)
    {
        pthread_join(tids[i], nullptr);
    }

    return 0;
}

运行结果为：

image-20240229211018969

所以其实在线程和线程当中没有秘密，只不过我们要求每一个线程有自己独立的栈，但是他们还在通一个地址空间中，线程的栈上的数据，也是可以被其他线程看到并且访问的。如果我们一个线程想要访问另一个线程的值，当然可以访问，只不过我们平时禁止这样做。

4.线程的局部存储

如下所示，代码是多线程访问同一个变量的代码

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3

//int *p = NULL;

int g_val = 100;

struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    //int test_i = 0;
    threadData *td = static_cast<threadData*>(args);
    // if(td->threadname == "thread-2")
    // {
    //     p = &test_i;
    // }
    int i = 0;
    while(i < 10)
    {
        cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) 
        << ", threadname : " << td->threadname 
        << ", g_val: " << g_val << ", &g_val: " << &g_val << endl; 

       // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;

        sleep(1);
        i++;
        g_val++;
      //  test_i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
    }
    sleep(1); //确保复制成功
   // cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   

    for(int i = 0; i < tids.size(); i++)
    {
        pthread_join(tids[i], nullptr);
    }

    return 0;
}

运行结果为：

image-20240229212555074

所以全局变量是被所有的线程看到并同时访问的。

这个g_val就是共享资源。

但是如果一个线程想要一个私有的全局变量呢？

所以我们可以下面这样做：在全局变量之前加上**__thread**

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3

//int *p = NULL;

__thread int g_val = 100;

struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    //int test_i = 0;
    threadData *td = static_cast<threadData*>(args);
    // if(td->threadname == "thread-2")
    // {
    //     p = &test_i;
    // }
    int i = 0;
    while(i < 10)
    {
        cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) 
        << ", threadname : " << td->threadname 
        << ", g_val: " << g_val << ", &g_val: " << &g_val << endl; 

       // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;

        sleep(1);
        i++;
        g_val++;
      //  test_i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
    }
    sleep(1); //确保复制成功
   // cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   

    for(int i = 0; i < tids.size(); i++)
    {
        pthread_join(tids[i], nullptr);
    }

    return 0;
}

运行结果为

image-20240229213247688

这样的对一个变量加上__thread的，我们将这个称作线程的局部存储

而我们前面正好就说了:在线程的tcb中，就有一个线程的局部存储

image-20240229213409277

所以我们可以明显看到，这个变量应该就在动态库中存储着。

这个__thread其实就是编译器编译时候的一个默认选项。

我们也可以直接从前面的两个图中的地址可以看出，没加这个选项的地址比较小（在静态区），加上这个选项地址比较大（处于堆栈之间的共享区）。

注意：这个__thread选项只能定义内置类型，不能用来修饰自定义类型

有了这个选项，对于某些只属于这个线程的变量，我们可以使用这个__thread来进行修饰，让它变为局部存储。这样的好处是可以不用频繁的去调用某些系统调用接口。

image-20240229214128231

这样就实现了线程级别的全局变量，和其他线程互不干扰。

二、分离线程

  • 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
  • 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源
#include <pthread.h>
int pthread_detach(pthread_t thread);
//Compile and link with -pthread.

这个分离接口既可以由主线程来做，也可以由其他新线程来做

我们可以先在join前先分离一下，看看是什么结果

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
#include <cstring>
#include <cstdio>
using namespace std;
#define NUM 3

//int *p = NULL;

__thread int g_val = 100;
__thread int number = 0;
struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    //int test_i = 0;
    threadData *td = static_cast<threadData*>(args);
    number = pthread_self();
    // if(td->threadname == "thread-2")
    // {
    //     p = &test_i;
    // }
    int i = 0;
    while(i < 10)
    {
        //cout << "number: " << number << ", pid: " << getpid() << endl;
        printf("number: 0x%x, pid: %d\n", number, getpid());
        //cout << "pid: " << getpid() << ", tid : " << toHex(number) << ", threadname : " << td->threadname << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;         
        // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;
        sleep(1);
        i++;
        g_val++;
      //  test_i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
    }
    usleep(100000); //确保复制成功
    // cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   

    for(auto i : tids)
    {
        pthread_detach(i);
    }

    for(int i = 0; i < tids.size(); i++)
    {
        int n = pthread_join(tids[i], nullptr);
        printf("n = %d, who = 0x%x, why: %s\n", n , tids[i], strerror(n));
    }
 
    return 0;
}

运行结果为：

image-20240301162551454

可见我们将线程给detach以后，再去join就不会成功了

我们也可以线程自己把自己分离掉

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
#include <cstring>
#include <cstdio>
using namespace std;
#define NUM 3

//int *p = NULL;

__thread int g_val = 100;
__thread int number = 0;
struct threadData
{
    string threadname;
};
string toHex(pthread_t tid)
{
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "0x%x", tid);
    return buffer;
}
void* threadRoutine(void* args)
{
    pthread_detach(pthread_self());
    //int test_i = 0;
    threadData *td = static_cast<threadData*>(args);
    number = pthread_self();
    // if(td->threadname == "thread-2")
    // {
    //     p = &test_i;
    // }
    int i = 0;
    while(i < 10)
    {
        //cout << "number: " << number << ", pid: " << getpid() << endl;
        printf("number: 0x%x, pid: %d\n", number, getpid());
        //cout << "pid: " << getpid() << ", tid : " << toHex(number) << ", threadname : " << td->threadname << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;         
        // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;
        sleep(1);
        i++;
        g_val++;
      //  test_i++;
    }

    delete td;
    return nullptr;
}


void InitThreadData(threadData* td, int number)
{
    td->threadname = "thread-" + to_string(number); 
}

int main()
{
    vector<pthread_t> tids;
    for(int i = 0; i < NUM; i++)
    {
        //注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次
        //td也要随之销毁掉。这里传入的全部都是野指针了。
        // threadData td;
        // td.threadname = "";
        // td.tid = "";
        pthread_t tid;
        threadData *td = new threadData;
        InitThreadData(td, i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
    }
    usleep(100000); //确保复制成功
    // cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   

    // for(auto i : tids)
    // {
    //     pthread_detach(i);
    // }

    for(int i = 0; i < tids.size(); i++) 
    {
        int n = pthread_join(tids[i], nullptr);
        printf("n = %d, who = 0x%x, why: %s\n", n , tids[i], strerror(n));
    }
 
    return 0;
}

运行结果也是一样的

image-20240301162921478

当线程内部的函数结束之后，会自动释放掉线程的资源

我们上面两个例子会发现一个问题，那就是分离线程应该会在线程跑完之后进行回收的。但是为什么还没有跑完就被回收了呢。这是因为我们在下面就有一个join，去等待了线程了。它在等待的发现已经被分离了。就不是阻塞式的等了，立马就出错返回了。出错返回后，这个for循环立刻就跑完了，跑完之后，主线成结束了，所以进程就结束了。所以虽然上面的线程还没有跑完，但是进程已经结束了，这些资源也就被释放了。

这里也告诉我们，即便我们的主线程将线程分离了，不用等待了，但是我们还是要自己去确保主线程是最后退出的，否则会出现一些问题。

所以线程是否被分离其实就是一个属性状态。它一定是要被存储的。所以线程分离其实就是将这个属性进行了修改

青色_忘川
关注
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
【Linux系统编程二十六】：线程控制与线程特性(Linux中线程库/线程创建/线程退出/线程等待)
Extreme_wei的博客
01-03 989
【Linux系统编程二十六】：本篇总结Linux下线程库中如何控制线程，理解线程控制块都是在线程库中被统一管理起来，线程tid的本质就是TCB在共享区里的起始地址。熟悉掌握线程的创建，退出，等待等操作，了解线程的一些特性：独立栈，局部存储，可分离线程等。
linux学习：线程
weixin_59669309的博客
04-25 803
以上 API 都是针对线程属性操作的，所谓线程属性是类型为 pthread_attr_t 的 变量，设置一个线程的属性时，通过以上相关的函数接口，将需要的属性添加到该类型 变量里面，再通过 pthread_create( )的第二个参数来创建相应属性的线程。而在线程接受取消请求的情况下，如何停下来又取决于两种不同的响应取消请求的策略 ——延时响应和立即响应，当采取延时策略时，线程并不会立即退出，而是要遇到所谓的“取 消点”之后，才退出。而“取消点”，指的是一系列指定的函数。
【Linux篇】第十四篇——多线程（一）（线程概念+线程控制）
m0_58367586的博客
10-05 6566
Linux下的线程线程的概念需要明确的是，一个进程的创建实际上伴随着其进程控制块(task_struct),进程地址空间(mm_struct)以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。每个进程都有自己独立的进程地址空间和独立的页表，也就意味着所有进程在运行时本身就具有独立性。但如果我们在创建"进程"时，只创建task_struct,并要求创建出来的task_struct和父task_struct共享进程地址空间和页表，那么创建出来的结果就是下面这样"
【Linux多线程】详解线程控制、线程分离
广西彭于晏的博客
07-30 275
如果不使用 pthread_detach，当一个线程终止时，它的资源将一直保留在系统中，直到其他线程调用 pthread_join 来回收它的资源。具体来说，pthread_detach 函数用于向线程库指示，当目标线程（被调用 pthread_detach 的线程）终止时，其状态和资源可以被系统回收，而不需要其他线程调用 pthread_join 来等待其终止。当一个线程被标记为“可分离”，则在该线程终止时，线程的资源会自动释放，而无需其他线程调用 pthread_join 来等待和回收该线程的资源。
Linux：线程
忘忧.
05-28 1183
本章所讲的线程原理，仅仅是Linux下的线程。在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“ 一个进程内部的控制序列 ”。一切进程至少都有一个执行线程。线程在进程内部运行，本质是在进程地址空间内运行。在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。课本：线程是比进程更加轻量级的一种执行流 / 线程是在进程内部执行的一种执行流。
【Linux系统编程：线程】 线程控制 -- 创建、终止、等待、分离 | 线程互斥与同步 | 互斥量与条件变量 | 生产者消费者模型 | 线程池 | STL/智能指针与线程安全 | 读者写者模型
wh128341的博客
12-07 2407
本文重点：基本上很多操作系统的书上对线程的解释是：线程是进程的一个执行分支，是在进程内部运行的一个执行流。而到具体一款操作系统，我们将从是什么、为什么、怎么办三个角度来解释线程。我们先来谈线程是什么的问题？对于上图，我们当然很熟悉，现在就可以明确了，这里是一张用户级页表，内核页表就不画了，我们都知道可执行程序在磁盘中无非就是代码或数据，更准确点表述，代码也是一种数据，程序一运行，实际就会将其加载到物理内存，因为每个进程都有地址空间和页表，所以可以通过用户页表映射物理内存的方式，来找到磁盘或内存中的数据。当然
【嵌入式软件工程师面经】Linux系统编程（线程进程）
妄北y
04-26 1599
熟练掌握这些概念和技术，以及相关的API和工具，是成为一名高效的Linux系统程序员的关键。面试前的充分准备将有助于展示你的能力和经验。
【Linux】多线程——线程概念|Linux下进程与线程|线程控制
weixin_60478154的博客
03-30 1894
【Linux】多线程——线程概念|Linux下进程与线程|线程控制
理解 Linux 线程
3166375975@的博客
04-20 410
目录 线程与进程 进程 ID 和线程 ID pthread 库接口 线程的创建和标识 pthread_create 函数 参数介绍 返回值 线程 ID 及进程地址空间布局 两类线程 ID 说明 进程地址空间 线程创建的默认属性 线程的退出 线程的连接与分离 线程的连接 为什么要连接退出的线程 线程的分离 互斥量 为什么需要互斥量 互斥量的接口 互斥量的初始化...
linux子线程运行的函数_Linux中线程使用详解
weixin_29367347的博客
12-24 447
4. 线程的属性前面还说到过线程创建的时候是有属性的，这个属性由一个线程属性对象来描述。线程属性对象由pthread_attr_init()接口初始化，并由pthread_attr_destory()来销毁，它们的完整定义是：intpthread_attr_init(pthread_attr_t*attr);intpthread_attr_destory(pthread_attr_t*at...
关于线程相关的知识
a_qq1215817063的博客
03-28 158
1) 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对 运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支 持，它也是一个很好的卖点。 2) 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存
最全的Java多线程面试题
yuan5883052的博客
03-23 668
1.线程和进程的区别是什么？ 根本区别：进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配。每个进程都有相应的线程，在执行程序时，实际上是执行相应的一系列线程。 地址空间：进程有自己独立的地址空间，每启动一个进程，系统都会为其分配地址空间，建立数据表来维护代码段、堆栈段和数据段；线程没有独立的地址空间，同一进程的线程共享本进程的地址空间。 资源拥有：进程之间的资源是独立的；同一进程内的线程共享本进程的资源。 执.
【LINUX】SHELL贪吃蛇
09-11 446
Show()#Mapdo;;;esacdone#Snakefor ((i=0;i++))doecho "*"done#Foodecho "0"dodoneMove();;;;esacArrayMovethenthenthenthenfithen。
navicate远程linux上的pgsql提示密码失败
记录、分享、合作、共赢
09-14 163
2、postgresql.conf文件中，修改listen_addresses。3、重启pgsql，例如：systemctl restart pgsql。1、pg_hba.conf文件中，ipv4下面的内容改成。4、如果问题还在，检查firewalld防火墙，执行。5、再次尝试连接，成功！
GDB的基本使用方法（之二）
相忘于江湖的专栏
09-14 509
要调试守护进程（daemon process）等已经启动的进程，或是调试陷入死循环而无法返回控制台的进程时，可以使用attach命令，形式是： (gdb) attach PID attach之后就能使用普通的gdb命令，因此可以通过print显示变量，也可以设置断点。 此外，回复程序运行一般可以使用continue命令。 确认了行为之后，需要在gdb和进程分离时使用detach命令： (gdb) detach
计算机网络30——Linux-gdb调试命令&makefile
最新发布
weixin_74681777的博客
09-14 404
在已经生成后，修改一个文件，重新执行时只会重新编译修改的文件，其余不会变。myapp是要生成的可执行文件的名字，main.c是依赖文件的名字。逐过程：next，如果调用其他函数，也不进入，直接进入下一条语句。编译时带-g为调试，带调试信息编译后的可执行文件更大。l 行号——行号的行在中间，向上向下展示10行。开始调试，断点默认停在main函数第一行。使用gdb 可执行文件名——进入调试。2、测试makefile文件（1）停在第一个断点处，开始调试。（1）准备一个main文件。如果没有修改，不会重新编译。
【Linux】ldd常见问题
zclinux的博客
09-11 983
当你自己编译程序时，可以通过。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青色_忘川

你的鼓励是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值