Created by QQ：851301776, mailbox ：[email protected], Welcome to technical exchange , This blog is mainly my own learning experience , Just to make a little progress every day ！

Personal motto ：
1. No one was born , As long as it is thick, it will happen .
2. You can have a low degree , You can skip school , But you have to learn

One 、 problem

          Suppose there is a global variable in the dynamic library , The calling function provided by the dynamic library , The essence is to operate this global variable . If multiple processes call this dynamic library at the same time , Can you , Is it safe .

        My answer is ： Sure .

        The next question is ： Why? ？ 

        Then I was confused .

        alas , How many times have you been asked , There has been no actual test summary , Today I want to summarize , I hope I can really understand .

Two 、 actual combat

1. Make a dynamic library （libhello.so）

(1) Content of header file

#ifndef     __HELLO_H__
#define     __HELLO_H__

int hello_add();

#endif 

（2） Contents in the source file

#include <stdio.h>
#include "hello.h"

int num = 0;

int hello_add()
{
    printf("num=%d\n", num++);
    return 0;
}

2. Write two processes

（1） process 1 Content

#include <stdio.h>

#include "./so/hello.h"

int main(void)
{
    int i = 100;
    while(i--)
    {
        sleep(1);
        printf("%s %d %s\n", __FILE__, __LINE__, __func__);
        hello_add();
    }
}

（2） process 2 Content

#include <stdio.h>

#include "../so/hello.h"

int main(void)
{
    int i = 100;
    while(i--)
    {
        sleep(1);
        printf("%s %d %s\n", __FILE__, __LINE__, __func__);
        hello_add();
    }
}

3. Print the results

 4. Conclusion

         Multiple processes access the same dynamic library at the same time , Operate on global variables , Don't affect each other .

  3、 ... and 、 reason

  explain ：dll yes windows Dynamic library in

         When the process that accesses the dynamic link library is loaded , The system will allocate 4GB Private address space （ If it is 32 Bit machine ）, Then the system will analyze the executable module , Find the executable module that will be called DLL, Then the system is responsible for searching these DLL Find these DLL After that, I put these DLL Load into memory , And allocate virtual memory space for them , The final will be DLL The page of is mapped to the address space summary of the calling process ,DLL Virtual memory has code pages and data pages , They are mapped separately to processes A Code page and data page , If this process B Also launched , And the process B Maybe you want to visit this DLL, At this time , Just put the DLL The code page and data page in the virtual memory can be mapped to the address space of the second process . There is only one copy of the unchanged code segment and data segment , The content that will change is the copy of each process itself .

Four 、 The difference between a dynamic library and a static library  

Static library ： Executable generated using static library links , It is to copy the modules used in the static library to the executable .
therefore , Such executables no longer depend on static library files

Dynamic library ： When the code is loaded into memory for execution , Just happened . Delayed link , Also called on-demand loading   , In the process of program execution , When you need to use dynamic libraries , Then apply to the system to load the dynamic library into memory .

5、 ... and 、 Memory management of processes

Each process has the following segments ：

（1） Code segment ： Read only executable

（2） Data segment ： Can read but write , Unenforceable , It mainly stores initialized global variables and static Declared variables

（3） Stack segment ： Can read but write , Unenforceable , A stack segment contains multiple stack frames . Each function has its own stack frame . During function execution , Stack frame of function exists , End of function call , The stack frame corresponding to the function disappears . The life cycle of the stack segment is the whole process   The life cycle of a process .

（4） Reactor section ： Can read but write , Unenforceable

（5）BSS paragraph ： Can be read , It mainly stores uninitialized global variables and initializes to 0 Global variable of