Dilemma about shared libraries on Unix

Question

If I build a shared library (shared object) I can use it in two following ways:
First way is to use a shared library like I would use a static library.

           #include "myLib.h"
           //...
           //afterwards I can use functions defined in mylib.h
           myFunction();

The second way of using shared library is by calling dynamic loader API functions: dlopen, dlsym, and dlclose from dlfcn.h. I would use shared library in this way when I want to implement a plugin pattern, for example. Listing would look like this:

#include <dlfcn.h>

void  *myLib;                /*  Handle to shared lib file  */
void (*myFunction)();       /*  Pointer to loaded function  */

  //...

  //load shared object
  myLib = dlopen("/home/dlTest/myLib.so",RTLD_LAZY);
  dlerror();

  //get handle to function
  myFunction = dlsym( myLib, "myFunction");
  dlerror();

  //execute function
  (*myFunction)();

  //close lib
  dlclose(myLib);
  dlerror();

Now my first question is: what is the difference between these two usages of shared object in terms of loading time? By using shared library in first way, we're linking/loading shared library to main app in load-time and in the second way we're doing the same thing in run-time?

Second question. What is the name of these two usages? First one is called statically linked shared library and the second one is dynamically linked/loaded shared library?

Third question If I've built a shared library without -fPIC flag (osition independent code), would I be able to use it in a second way?

Cheers

Answer 1

These two use modes are typically called implicit and explicit. As you correctly stated the difference in loading is that explicitly linked dynamic library is loaded when dlopen is executed and implicitly linked library is loaded at the time the application is loaded in memory. Each dlopen may take milliseconds to finish, unless library was already loaded, in which case it's very fast, so if you have very stringent latency requirements or need to do frequent loading/unloading then you may decide to make linking implicit or explicitly load the library on program start and don't unload it until it's no longer used.