@@ -87,11 +87,14 @@
         1.  [sstream](sstream.cpp)
         1.  [iostream](iostream.cpp)
         1.  [File IO](file_io.cpp)
-    1.  [thread](thread.cpp)
-        1.  [sleep_for](sleep_for.cpp)
+    1.  Multi-threading
+        1.  [thread::hardware_concurrency](thread_hardware_concurrency.cpp)
+        1.  [thread::this_thread::sleep_for](sleep_for.cpp)
+        1.  [thread return value](thread_return_value.cpp)
         1.  [atomic](atomic.cpp)
             1.  [atomic<bool>](atomic_bool.cpp.off)
-        1.  [mutex](mutex.cpp)
+        1.  [sleep_for](interactive/sleep_for.cpp)
+        1.  [mutex](interactive/mutex.cpp)
     1.  [algorithm](algorithm.cpp)
         1.  [heap](heap.cpp)
     1.  [functional](functional.cpp)
@@ -115,9 +118,6 @@
     1.  [bst_vs_heap](interactive/bst_vs_heap.cpp)
     1.  [chrono](interactive/chrono.cpp)
     1.  [random](interactive/random.cpp)
-    1.  thread
-        1.  [sleep_for](interactive/sleep_for.cpp)
-        1.  [thread_count](interactive/thread_count.cpp)
 1.  Applications
     1. [Design patterns](design_patterns.cpp)
 
 
@@ -0,0 +1,73 @@
+// Only allows one thread to enter the critical zone.
+//
+// Usage:
+//
+//     ./mutex.out [num_iters [num_threads [use_mutex=0|1]]
+//
+// Should work because uses mutex:
+//
+//     ./mutex.out 1000 10 1
+//
+// Fails for large num_iters large enough with more than one thread
+// due to synchroniation problems:
+//
+//     ./mutex.out 1000 10 0
+//
+// This is an artificial example: the more restricted and efficient atomic would be a better fit.
+//
+// http://stackoverflow.com/questions/6837699/are-mutex-lock-functions-sufficient-without-volatile
+
+#if __cplusplus >= 201103L
+#include <cassert>
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+std::mutex mutex;
+unsigned int num_threads;
+unsigned int use_mutex = 1;
+unsigned long global = 0;
+unsigned long long num_iters = 0;
+
+void thread_main() {
+    for (decltype(num_iters) i = 0; i < num_iters; ++i) {
+        if (use_mutex)
+            mutex.lock();
+        global++;
+        if (use_mutex)
+            mutex.unlock();
+    }
+}
+#endif
+
+int main(int argc, char **argv) {
+#if __cplusplus >= 201103L
+    if (argc > 1) {
+        num_iters = std::strtoull(argv[1], NULL, 10);
+    } else {
+        num_iters = 10;
+    }
+    if (argc > 2) {
+        num_threads = std::strtoull(argv[2], NULL, 10);
+    } else {
+        num_threads = std::thread::hardware_concurrency();
+    }
+    if (argc > 3) {
+        use_mutex = (argv[3][0] == '1');
+    } else {
+        use_mutex = 1;
+    }
+
+    std::vector<std::thread> threads(num_threads);
+    for (auto& thread : threads)
+        thread = std::thread(thread_main);
+    for (auto& thread : threads)
+        thread.join();
+    auto num_ops = num_threads * num_iters;
+    if (global != num_ops) {
+        std::cout << "fraction of errors " << ((double)global / num_ops) << std::endl;
+        assert(false);
+    }
+#endif
+}
@@ -1,3 +1,5 @@
+// Count to infinity sleeping one second per number.
+
 #include "common.hpp"
 
 int main() {
 
@@ -0,0 +1,10 @@
+// http://stackoverflow.com/questions/150355/programmatically-find-the-number-of-cores-on-a-machine
+//
+// Not affected by taskset: https://stackoverflow.com/questions/1006289/how-to-find-out-the-number-of-cpus-using-python/55423170#55423170
+
+#include <iostream>
+#include <thread>
+
+int main() {
+    std::cout << std::thread::hardware_concurrency() << std::endl;
+}
@@ -0,0 +1,27 @@
+// Spawn some threads and print their ID.
+//
+// On Ubuntu 19.04, they were not consecutive numbers.
+
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+std::mutex mutex;
+
+void myfunc(int i) {
+    mutex.lock();
+    std::cout << i << " " << std::this_thread::get_id() << std::endl;
+    mutex.unlock();
+}
+
+int main() {
+    std::cout << "main " << std::this_thread::get_id() << std::endl;
+    std::vector<std::thread> threads;
+    for (unsigned int i = 0; i < 4; ++i) {
+        threads.push_back(std::thread(myfunc, i));
+    }
+    for (auto& thread : threads) {
+        thread.join();
+    }
+}
@@ -1,22 +1,64 @@
-/*
-# thread return value
+// http://stackoverflow.com/questions/7686939/c-simple-return-value-from-stdthread
+// http://stackoverflow.com/questions/28950835/c-error-no-type-named-type-in-class-stdresult-ofvoid-stdunordered
+// http://stackoverflow.com/questions/21048906/stdthread-pass-by-reference-calls-copy-constructor
+// http://stackoverflow.com/questions/8299545/passing-arguments-to-thread-function
+// http://stackoverflow.com/questions/5116756/difference-between-pointer-and-reference-as-thread-parameter
 
-    An actual return value is impossible, you need to use other wrappers:
+#include <cassert>
+#include <future>
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <vector>
 
-    - http://stackoverflow.com/questions/7686939/c-simple-return-value-from-stdthread
+std::mutex mutex;
 
-    Shared state will of course work.
+int myfunc(int i) {
+    return i + 1;
+}
 
-    Passing reference arguments to be modified has weird results:
+void myfunc_reference(int& i) {
+    i = myfunc(i);
+}
 
-    - http://stackoverflow.com/questions/28950835/c-error-no-type-named-type-in-class-stdresult-ofvoid-stdunordered
-    - http://stackoverflow.com/questions/21048906/stdthread-pass-by-reference-calls-copy-constructor
-    - http://stackoverflow.com/questions/8299545/passing-arguments-to-thread-function
-    - http://stackoverflow.com/questions/5116756/difference-between-pointer-and-reference-as-thread-parameter
-*/
+int main() {
+    unsigned int nthreads = 4;
+    std::vector<int> inputs{1, 2, 3, 4};
+    std::vector<int> outputs_expect{2, 3, 4, 5};
 
-#include "common.hpp"
+    // future and sync. Nirvana. When you are not fighting to death with types:
+    // https://stackoverflow.com/questions/10620300/can-stdasync-be-use-with-template-functions
+    {
+        std::vector<std::future<int>> futures(nthreads);
+        std::vector<int> outputs(nthreads);
+        for (decltype(futures)::size_type i = 0; i < nthreads; ++i) {
+            futures[i] = std::async(
+                myfunc,
+                inputs[i]
+            );
+        }
+        for (decltype(futures)::size_type i = 0; i < nthreads; ++i) {
+            outputs[i] = futures[i].get();
+        }
+        assert(outputs_expect == outputs);
+    }
 
-int main() {
-    // TODO
+    // Reference arguments.
+    //
+    // Annoying because requires:
+    //
+    // - wrapping the return function to accept references
+    // - keeping an array of outputs
+    // - std::ref
+    {
+        std::vector<std::thread> threads(nthreads);
+        std::vector<int> inouts(inputs);
+        for (decltype(threads)::size_type i = 0; i < nthreads; ++i) {
+            threads[i] = std::thread(myfunc_reference, std::ref(inouts[i]));
+        }
+        for (auto& thread : threads) {
+            thread.join();
+        }
+        assert(outputs_expect == inouts);
+    }
 }
@@ -1,3 +1,8 @@
 # Basic
 
 Basic example. Creates a shared and a static library from `a.c` and `b.c`.
+
+Used in the following answers:
+
+- https://unix.stackexchange.com/questions/89211/how-to-test-whether-a-linux-binary-was-compiled-as-position-independent-code/435038#435038
+- https://unix.stackexchange.com/questions/226524/what-system-call-is-used-to-load-libraries-in-linux/462710#462710
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// Count to infinity sleeping one second per number.`
	`2`	`+`
`1`	`3`	`#include "common.hpp"`
`2`	`4`
`3`	`5`	`int main() {`