Lec10b.synchronize.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synchronization and Thread Safety\n",
    "\n",
    "Uncontrolled reading and writing of shared variables leads to unpredictable outcomes.  Reading and writing without synchronization leads to __race conditions__ in which computations produce different results depending the order in which threads are executed by the operating system.\n",
    "\n",
    "<img src=\"https://i.stack.imgur.com/m7HYo.png\" width=512 title=\"Race Condition\" />\n",
    "\n",
    "The problem arises because `x = x + 1` is actually multiple operations.  Each thread:\n",
    "\n",
    "```\n",
    "reads value of x for memory\n",
    "updates local copy of x\n",
    "writes local copy to memory\n",
    "```\n",
    "\n",
    "Race conditions lead to bugs when one of the outcomes is undesirable.  It is the job of the programmer to __explicitly order__ operations so that bugs do not arise.\n",
    "\n",
    "__Thread safety__ is the idea that functions can be called from multiple threads concurrently and will produce correct results.  When you synchronize your code, it should be thread safe.\n",
    "\n",
    "We will look at several constructs for synchronization in Java:\n",
    "  * `synchronized` blocks\n",
    "  * the volatile keyword\n",
    "  * `Atomic` variables \n",
    "\n",
    "The most frequent and useful operation is to place a `synchronize` block around racing operations.  This synchronization creates a __critical section__ of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shared variable = 79672038\n",
      "Shared synchronized variable = 80000000\n"
     ]
    }
   ],
   "source": [
    "class SynchronizedWorks implements Runnable\n",
    "{\n",
    "  // Create variables for testing.\n",
    "  static int sharedvar = 0;\n",
    "  static int sharedsynchvar = 0;\n",
    "\n",
    "  public void run ()\n",
    "  { \n",
    "    for ( int i=0; i<10000000; i++ )\n",
    "    {\n",
    "      sharedvar++;\n",
    "      synchronized(SynchronizedWorks.class){sharedsynchvar++;}\n",
    "    }\n",
    "  }\n",
    "}\n",
    "\n",
    "int numthreads = 4;\n",
    "Thread[] threads = new Thread[numthreads];\n",
    "\n",
    "// create and start thread objects\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i] = new Thread ( new SynchronizedWorks() );\n",
    "    threads[i].start();\n",
    "}\n",
    "\n",
    "// Await the completion of all threads\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i].join();\n",
    "}\n",
    "\n",
    "System.out.println(\"Shared variable = \" + SynchronizedWorks.sharedvar);\n",
    "System.out.println(\"Shared synchronized variable = \" + SynchronizedWorks.sharedsynchvar);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### synchronized\n",
    "\n",
    "* A Java `synchronize` block:\n",
    "  * Has only one thread accessing the block at a time.\n",
    "  * Is reconciled with memory at start and end of block.\n",
    "  * This notion of block is the same as OpenMP.  Single entry point, single exit point.\n",
    "      \n",
    "These guarantees ensure that the all of the operations of a thread are completed and all changes are written to a shared coherent memory before any other threads execute the block.  This is good enough to make the operation __atomic__.\n",
    "\n",
    "_Def'n_ __atomic__ a sequence of operations is executed by a processor as an indivisible unit that cannot be interrupted.\n",
    "\n",
    "This is a lame and controversial definition (see https://en.wikipedia.org/wiki/Linearizability), but is adequate for us.  The notion is that all the operations happen as an \"atom\" that cannot be divided. \n",
    "\n",
    "While we're criticizing definitions, _synchronized_ is a terrible word.  It means _v. To make two or more events happen at exactly the same time or at the same rate._  This is not what the way it's used in CS.\n",
    "\n",
    "\n",
    "### volatile\n",
    "\n",
    "Java implements the the declaration specifier `volatile`, which it inherited from C/C++.  Variables that are declared as `volatile`\n",
    "* read the variable from memory\n",
    "* write the variable to memory\n",
    "<!-- * ensure the all operators are atomic RB TODO -->\n",
    "This seems like it might be good enough.......but alas.  The problem is that even though all operations are atomic, the combination of operations is not.\n",
    "\n",
    "I point this out because many programmers have read about volatile and thought it would get the job done.  `volatile` is an important building block for concurrency control, but not useful to application programmers directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shared variable = 33647291\n",
      "Shared volatile variable = 33168335\n"
     ]
    }
   ],
   "source": [
    "class VolatileWorks implements Runnable\n",
    "{\n",
    "  static int sharedvar = 0;\n",
    "  static volatile int sharedvolvar = 0;\n",
    "\n",
    "  public void run ()\n",
    "  {\n",
    "    for ( int i=0; i<10000000; i++ )\n",
    "    {\n",
    "      sharedvolvar++;\n",
    "      sharedvar++;\n",
    "    }\n",
    "  }\n",
    "}\n",
    "\n",
    "int numthreads = 4;\n",
    "Thread[] threads = new Thread[numthreads];\n",
    "\n",
    "// create and start thread objects\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i] = new Thread ( new VolatileWorks() );\n",
    "    threads[i].start();\n",
    "}\n",
    "\n",
    "// Await the completion of all threads\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i].join();\n",
    "}\n",
    "\n",
    "System.out.println(\"Shared variable = \" + VolatileWorks.sharedvar);\n",
    "System.out.println(\"Shared volatile variable = \" + VolatileWorks.sharedvolvar);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### java.util.concurrent.atomic\n",
    "\n",
    "Java also provides \"atomic\" classes that wrap all basic types.  They make all basic operations on these variables atomic through member functions.  They do so with a \"lock-free, thread safe encapsulation of fundamental types.\"  All operations are of the read/modify/write type that we will discuss in the concurrency lecture. That doesn't mean much now.  But, they guarantee atomicity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shared variable = 27299851\n",
      "Shared atomic variable = 40000000\n"
     ]
    }
   ],
   "source": [
    "import java.util.concurrent.atomic.AtomicInteger;\n",
    "\n",
    "class AtomicWorks implements Runnable\n",
    "{\n",
    "  static int sharedvar = 0;\n",
    "  static AtomicInteger sharedatomint = new AtomicInteger();\n",
    "\n",
    "  public void run ()\n",
    "  {\n",
    "    for ( int i=0; i<10000000; i++ )\n",
    "    {\n",
    "      sharedvar++;\n",
    "      sharedatomint.incrementAndGet();\n",
    "    }\n",
    "  }\n",
    "}\n",
    "\n",
    "int numthreads = 4;\n",
    "Thread[] threads = new Thread[numthreads];\n",
    "\n",
    "// create and start thread objects\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i] = new Thread ( new AtomicWorks() );\n",
    "    threads[i].start();\n",
    "}\n",
    "\n",
    "// Await the completion of all threads\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i].join();\n",
    "}\n",
    "\n",
    "System.out.println(\"Shared variable = \" + AtomicWorks.sharedvar);\n",
    "System.out.println(\"Shared atomic variable = \" + AtomicWorks.sharedatomint);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### On Performance\n",
    "\n",
    "The relative performance of these constructs depends on many things.  Here are some guidelines.\n",
    "* Atomics are best for single operations.  \n",
    "  * they are implemented with single instruction hardware support.\n",
    "  * they have to perform reads/writes to memory on every operation\n",
    "* Sychronized blocks are more flexible and better for multiple operations\n",
    "  * they are implemented with locking\n",
    "  * compiler can keep variables in registers during block execution\n",
    "  * memory is written only on block exit\n",
    "\n",
    "Typical practice is to use synchronized blocks and not worry too much.  But rememeber, __all code in a sycnhronized block is running serially__, regardless of how many threads/cores/etc. your system has.  Minimize code in synchronized blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `synchronize` bug\n",
    "\n",
    "Synchronized only applies to an object (or class). A frequent mistake is to apply to an object and assume it will synchronize all objects of this class. This type of error quite difficult to find and debug.\n",
    "\n",
    "It can be right to synchronize to an object and I have many examples.  But, our examples do the following:\n",
    "  * map an object to a thread\n",
    "  * synchronize on the class to ensure that only one thread accesses shared data\n",
    "  \n",
    "This approach is good parallel design and is robust."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shared variable = 16418941\n",
      "Shared synchronized variable = 16421812\n"
     ]
    }
   ],
   "source": [
    "class SynchronizedBug implements Runnable\n",
    "{\n",
    "  static int sharedvar = 0;\n",
    "  static int sharedsynchvar = 0;\n",
    "\n",
    "  public void run ()\n",
    "  { \n",
    "    for ( int i=0; i<10000000; i++ )\n",
    "    {\n",
    "      sharedvar++;\n",
    "      // NOTE synchronizing on object not class\n",
    "      synchronized(this){sharedsynchvar++;}\n",
    "    }\n",
    "  }\n",
    "}\n",
    "\n",
    "int numthreads = 4;\n",
    "Thread[] threads = new Thread[numthreads];\n",
    "\n",
    "// create and start thread objects\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i] = new Thread ( new SynchronizedBug() );\n",
    "    threads[i].start();\n",
    "}\n",
    "\n",
    "// Await the completion of all threads\n",
    "for ( int i=0; i<numthreads; i++ )\n",
    "{\n",
    "    threads[i].join();\n",
    "}\n",
    "\n",
    "System.out.println(\"Shared variable = \" + SynchronizedBug.sharedvar);\n",
    "System.out.println(\"Shared synchronized variable = \" + SynchronizedBug.sharedsynchvar);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synchronizing on Objects versus Classes\n",
    "\n",
    "The parallel pattern used most typically by application programmers is to:\n",
    "* create parallel objects that are members of the same class\n",
    "* run each object in its own thread\n",
    "* `synchronize` on the class\n",
    "   \n",
    "In this case, the threads are all objects in the same class and no two objects of the same class should be running a `critical section` at the same time.  We observe that there is a one-to-one mapping between threads and objects in this class, i.e. each object runs in serial; each object is `single threaded`.\n",
    "\n",
    "_When would you synchronize on an object, not a class?_\n",
    "\n",
    "Consider that you are developing parallel functions that you are expecting to be called concurrenlty by multiple threads. This results in a different pattern.\n",
    "* Multiple threads hold a reference to one object.\n",
    "* Each thread calls parallel functions in their own thread context.\n",
    "\n",
    "In this case, there are multiple threads calling a single object in parallel and the `critical section` needs to be applied on the object, not the class.\n",
    "\n",
    "Any parallel service that performs logging to a single file uses this pattern. For example, an image processing pipepline with multiple steps may parallelize execution on a per image basis.\n",
    "* each thread calls the library with a image file\n",
    "* for each step in the pipeline:\n",
    "    * perform the processing in parallel (no data dependencies)\n",
    "    * in a critical section on the object, log status, progress, and errors to shared log.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "17.0.3+7-LTS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}