Dynamic loading is a mechanism by which a computer program can, at run time, load a library (or other binary) into memory, retrieve the addresses of functions and variables contained in the library, execute those functions or access those variables, and unload the library from memory. It is one of the 3 mechanisms by which a computer program can use some other software; the other two are static linking and dynamic linking. Unlike static linking and dynamic linking, dynamic loading allows a computer program to start up in the absence of these libraries, to discover available libraries, and to potentially gain additional functionality.^[1][2]

History

Dynamic loading was a common technique for IBM's operating systems for System/360 such as OS/360, particularly for I/O subroutines, and for COBOL and PL/I runtime libraries, and continues to be used in IBM's operating systems for z/Architecture, such as z/OS. As far as the application programmer is concerned, the loading is largely transparent, since it is mostly handled by the operating system (or its I/O subsystem). The main advantages are:

• Fixes (patches) to the subsystems fixed all programs at once, without the need to relink them
• Libraries could be protected from unauthorized modification

IBM's strategic transaction processing system, CICS (1970s onwards) uses dynamic loading extensively both for its kernel and for normal application program loading. Corrections to application programs could be made offline and new copies of changed programs loaded dynamically without needing to restart CICS^[3][4] (which can, and frequently does, run 24/7).

Shared libraries were added to Unix in the 1980s, but initially without the ability to let a program load additional libraries after startup.^[5]

Uses

Dynamic loading is most frequently used in implementing software plugins.^[1] For example, the Apache Web Server's *.dso "dynamic shared object" plugin files are libraries which are loaded at runtime with dynamic loading.^[6] Dynamic loading is also used in implementing computer programs where multiple different libraries may supply the requisite functionality and where the user has the option to select which library or libraries to provide.

In C/C++

Not all systems support dynamic loading. UNIX-like operating systems such as macOS, Linux, and Solaris provide dynamic loading with the C programming language "dl" library. The Windows operating system provides dynamic loading through the Windows API.

void* sdl_library = dlopen("libSDL.so", RTLD_LAZY);
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to dlsym
}

void* sdl_library = dlopen("libSDL.dylib", RTLD_LAZY);
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to dlsym
}

void* sdl_library = dlopen("/Library/Frameworks/SDL.framework/SDL", RTLD_LAZY);
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to dlsym
}

NSBundle *bundle = [NSBundle bundleWithPath:@"/Library/Plugins/Plugin.bundle"];
NSError *err = nil;
if ([bundle loadAndReturnError:&err])
{
    // Use the classes and functions in the bundle.
}
else
{
    // Handle error.
}

HMODULE sdl_library = LoadLibrary(TEXT("SDL.dll"));
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to GetProcAddress
}

void* initializer = dlsym(sdl_library,"SDL_Init");
if (initializer == NULL) {
   // report error ...
} else {
   // cast initializer to its proper type and use
}

Class rootClass = [bundle principalClass]; // Alternatively, NSClassFromString() can be used to obtain a class by name.
if (rootClass)
{
    id object = [[rootClass alloc] init]; // Use the object.
}
else
{
    // Report error.
}

FARPROC initializer = GetProcAddress(sdl_library,"SDL_Init");
if (initializer == NULL) {
   // report error ...
} else {
   // cast initializer to its proper type and use
}

typedef INT_PTR (*FARPROC)(void);

typedef void (*sdl_init_function_type)(void);
sdl_init_function_type init_func = (sdl_init_function_type) initializer;

typedef void (*sdl_init_function_type)(void);
sdl_init_function_type init_func = (sdl_init_function_type)initializer;

typedef void (*sdl_init_function_type)(void);
union { sdl_init_function_type func; void * obj; } alias;
alias.obj = initializer;
sdl_init_function_type init_func = alias.func;

dlclose(sdl_library);

FreeLibrary(sdl_library);

void* this_process = dlopen(NULL,0);

HMODULE this_process = GetModuleHandle(NULL);

HMODULE this_process_again;
GetModuleHandleEx(0,0,&this_process_again);

In Java

In the Java programming language, classes can be dynamically loaded using the ClassLoader object. For example:

Class type = ClassLoader.getSystemClassLoader().loadClass(name);
Object obj = type.newInstance();

The Reflection mechanism also provides a means to load a class if it isn't already loaded. It uses the classloader of the current class:

Class type = Class.forName(name);
Object obj = type.newInstance();

However, there is no simple way to unload a class in a controlled way. Loaded classes can only be unloaded in a controlled way, i.e. when the programmer wants this to happen, if the classloader used to load the class is not the system class loader, and is itself unloaded. When doing so, various details need to be observed to ensure the class is really unloaded. This makes unloading of classes tedious.

Implicit unloading of classes, i.e. in an uncontrolled way by the garbage collector, has changed a few times in Java. Until Java 1.2. the garbage collector could unload a class whenever it felt it needed the space, independent of which class loader was used to load the class. Starting with Java 1.2 classes loaded via the system classloader were never unloaded and classes loaded via other classloaders only when this other classloader was unloaded. Starting with Java 6 classes can contain an internal marker indicating to the garbage collector they can be unloaded if the garbage collector desires to do so, independent of the classloader used to load the class. The garbage collector is free to ignore this hint.

Similarly, libraries implementing native methods are dynamically loaded using the System.loadLibrary method. There is no System.unloadLibrary method.

Platforms without dynamic loading

Despite its promulgation in the 1980s through UNIX and Windows, some systems still chose not to add—or even to remove—dynamic loading. For example, Plan 9 from Bell Labs and its successor 9front intentionally avoid dynamic linking, as they consider it to be "harmful".^[9] The Go programming language, by some of the same developers as Plan 9, also did not support dynamic linking, but plugin loading is available since Go 1.8 (February 2017). The Go runtime and any library functions are statically linked into the compiled binary.^[10]

See also

References

Further reading

• Silberschatz, Abraham; Galvin, Peter Baer; Gagne, Greg (2005). "Chapter 8.1.4 "Dynamic Loading" and Chapter 8.1.5 "Dynamic Linking and shared libraries"". Operating System Concepts. J. Wiley & Sons. ISBN 978-0-471-69466-3.

External links

• General Links
  • Dynamic Loading on Linux4U
  • Dynamic Shared Object (DSO) Support by Apache
  • C++ Dynamic Linking By Example
  • Dynamic Library Loading Example (complete but concise working example)
  • Dynamic Library Programming Topics from Apple Developer Connection (targeted to macOS)
• C/C++ UNIX API:
  • dlopen
  • dlsym
  • dlclose
• C/C++ Windows API:
  • LoadLibrary
  • GetProcAddress
  • FreeLibrary
  • Delay-Loaded DLLs
• Java API:
  • ClassLoader
  • Class