Problems with threads after dlls are loaded

2. Open the toolbox and find "Computer Clinic".

DLL files, etc. are missing, corrupted, and some applications, including games, cannot be launched.

The workarounds are:

1. Use the windows system disk function to repair files;

2. If there has been a one-click backup before this, it can be restored again;

4. Due to the incompatibility of system files from the Internet, the system files may be incompatible because the system file version does not match the operating system, and it is best to use a professional tool to repair the system files with one click.

Uh, I don't know. If it is a window loaded inside the dll, it seems to be written under the starter subroutine to load (), I hope not to start the thread, the thread sometimes crashes, and it is very slow, but it can effectively prevent the program from freezing death; If the window is to be called externally, create a new subroutine to disable the window. Please understand that there is any error in this method.

It cannot be said that none of the functions in the DLL can be called in parallel. But if the dll itself uses global variables and is not synchronized, it definitely won't work, and this is the case with your dll.

Then you need to synchronize yourself, i.e. make sure that there is always only one thread calling:

object lockobj = new object();i) =>

The reason for this involves the DLL loading and running mechanism, and there are two main points:

1) The DLL dynamic link library cannot be run independently, and can only be used after it is loaded into the process space by an application process. The process that loads the DLLs is called the host process. The loaded DLLs belong to the host process, not to a thread in the host process.

2) The host process can be called repeatedly, or even load the dll repeatedly. The first call to the dll or the first load of the dll, the host process introduces the dll into the process space. Once the host process successfully loads the DLL, subsequent repeated calls or repeated loads will only increase the "reference count" and will not load multiple DLLs, so there will only be one DLL in the process.

c itself can support threads, so why bother to call dll to create threads.

I have the impression that Microsoft said not to create threads in dllmain, otherwise it will die miserably. MSDN

However, it should be possible to create threads in the export function. It should be your ** writing is wrong, but there is no need to go far.

It should be the implementation of your A function written in the header file. A calls Thread Create, but the implementation of Thread Create does not export from the dll, so this error occurs.

Solution: Write the implementation of the A function to a file, and only one declaration in the header file is enough. Remember to export the a function...

thread create does not need to be exported. One rule: as long as your client (i.e. the program calling the dll) can see thread create, there will definitely be a problem.

You just need to put the A function in the C file of DLL**, and leave only a declaration in the header file, so that the client will not see Thread Create, and there will be no error just now.

Nothing, equivalent to calling a function,

dll process. Are you sure you read Win Core Programming?