Updates to topics on thread-local storage to mention delay-load issues (#482)

* updates to thread and related topics for TLS note with DLLs

* fixed typo and formatting per review

* fixes per peer review

Author: mikeblome

docs/build/dll-frequently-asked-questions.md

@@ -31,7 +31,7 @@ Following are some frequently asked questions (FAQ) about DLLs.
 
 ## <a name="mfc_multithreaded_1"></a> Can an MFC DLL create multiple threads?  
 
-Except during initialization, an MFC DLL can safely create multiple threads as long as it uses the Win32 thread local storage (TLS) functions such as **TlsAlloc** to allocate thread local storage. However, if an MFC DLL uses **__declspec(thread)** to allocate thread local storage, the client application must be implicitly linked to the DLL. If the client application explicitly links to the DLL, the call to **LoadLibrary** will not successfully load the DLL. For more information about creating multiple threads inside MFC DLLs, see the Knowledge Base article, "PRB: Calling LoadLibrary() to Load a DLL That Has Static TLS" (Q118816).  
+Except during initialization, an MFC DLL can safely create multiple threads as long as it uses the Win32 thread local storage (TLS) functions such as **TlsAlloc** to allocate thread local storage. However, if an MFC DLL uses **__declspec(thread)** to allocate thread local storage, the client application must be implicitly linked to the DLL. If the client application explicitly links to the DLL, the call to **LoadLibrary** will not successfully load the DLL. For more information about creating multiple threads inside MFC DLLs, see the Knowledge Base article, "PRB: Calling LoadLibrary() to Load a DLL That Has Static TLS" (Q118816). For more information about thread-local variables in DLLs, see [thread](../cpp/thread.md).
 
  An MFC DLL that creates a new MFC thread during startup will stop responding when it is loaded by an application. This includes whenever a thread is created by calling `AfxBeginThread` or `CWinThread::CreateThread` inside:  
 

docs/c-language/thread-local-storage.md

@@ -28,7 +28,7 @@ __declspec( thread ) int tls_i = 1;
 
  These guidelines must be observed when you are declaring statically bound thread local variables:  
 
--   The use of **__declspec(thread)** may interfere with [delay loading](../build/reference/linker-support-for-delay-loaded-dlls.md) of DLL imports**.**  
+-   Thread-local variables that have dynamic initialization are only initialized on the thread that causes the DLL to load, and threads that are already running in the process. For more information, see [thread](../cpp/thread.md).  
 
 -   You can apply the thread attribute only to data declarations and definitions. It cannot be used on function declarations or definitions. For example, the following code generates a compiler error:  
 

docs/cpp/storage-classes-cpp.md

@@ -209,15 +209,13 @@ void DoSomething()
 ```  
 
 Things to note about the `thread_local` specifier:  
+
+- Dynamically initialized thread-local variables in DLLs may not be correctly initialized on all calling threads. For more information, see [thread](thread.md).
 
 -  The `thread_local` specifier may be combined with `static` or `extern`.  
 
 -  You can apply `thread_local` only to data declarations and definitions; `thread_local` cannot be used on function declarations or definitions.  
 
--  The use of `thread_local` may interfere with [delay loading](../build/reference/linker-support-for-delay-loaded-dlls.md) of DLL imports. 
-  
--  On XP systems, `thread_local` may not function correctly if a DLL uses `thread_local` data and it is loaded dynamically via `LoadLibrary`.  
-  
 -  You can specify `thread_local` only on data items with static storage duration. This includes global data objects (both `static` and `extern`), local static objects, and static data members of classes. Any local variable declared `thread_local` is implicitly static if no other storage class is provided; in other words, at block scope `thread_local` is equivalent to `thread_local static`. 
 
 -  You must specify `thread_local` for both the declaration and the definition of a thread local object, whether the declaration and definition occur in the same file or separate files.  

docs/cpp/thread.md

@@ -19,7 +19,7 @@ manager: "ghogen"
 # thread
 
 **Microsoft Specific**  
-The **thread** extended storage-class modifier is used to declare a thread local variable. For the portable equivalent in C++11 and later, use the [thread_local](../cpp/storage-classes-cpp.md#thread_local) storage class specifier.
+The **thread** extended storage-class modifier is used to declare a thread local variable. For the portable equivalent in C++11 and later, use the [thread_local](../cpp/storage-classes-cpp.md#thread_local) storage class specifier for portable code. On Windows **thread_local** is implemented with **__declspec(thread)**.
 
 ## Syntax
 
@@ -37,13 +37,18 @@ Declarations of thread local variables must use [extended attribute syntax](../c
 __declspec( thread ) int tls_i = 1;  
 ```
 
-You must observe these guidelines when declaring thread local objects and variables:
+When using thread-local variables in dynamically-loaded libraries, you need to be aware of factors that can cause a thread-local variable to not be initialized correctly:
 
-- You can apply the **thread** attribute only to class and data declarations and definitions; **thread** cannot be used on function declarations or definitions.
+1) If the variable is initialized with a function call (including constructors), this function will only be called for the thread that caused the binary/DLL to load into the process, and for those threads that started after the binary/DLL was loaded. The initialization functions are not called for any other thread that was already running when the DLL was loaded. Dynamic initialization occurs on the DllMain call for DLL_THREAD_ATTACH, but the DLL never gets that message if the DLL isn't in the process when the thread starts. 
+
+2) Thread-local variables that are initialized statically with constant values are generally initialized properly on all threads. However, as of December 2017 there is a known conformance issue in the Microsoft C++ compiler whereby constexpr variables receive dynamic rather than static initialization.  
+  
+   Note: Both of these issues are expected to be fixed in future updates of the compiler.
 
-- The use of the **thread** attribute may interfere with [delay loading](../build/reference/linker-support-for-delay-loaded-dlls.md) of DLL imports.
 
-- On XP systems, **thread** may not function correctly if a DLL uses __declspec(thread) data and it is loaded dynamically via LoadLibrary.
+Additionally, you must observe these guidelines when declaring thread local objects and variables:
+
+- You can apply the **thread** attribute only to class and data declarations and definitions; **thread** cannot be used on function declarations or definitions.
 
 - You can specify the **thread** attribute only on data items with static storage duration. This includes global data objects (both **static** and **extern**), local static objects, and static data members of classes. You cannot declare automatic data objects with the **thread** attribute.