Please enable JavaScript.

Coggle requires JavaScript to display documents.

Concurrency (Directly Control threads (immutable objects (fields cannot be…

- - - - implement
        Runnable interface
        
        implement run()
        
        instantiate a Thread class
        and pass runnable
        
        Thread.start()
        
        executes
        runnable's run()
      - extend
        Thread class
        
        overrite run()
        
        class.start()
    - - sleep(milisec)
        
        static method
        
        affects thread where it is called
    - - sleep() or wait()
        
        throw InterruptedException
        
        stop processing
      - other operation
        
        set internal interrupt
        flag of thread only
        
        trdObj.interrupt()
        
        interrupts thread
        
        trdObj.isInterrupted()
        
        returns boolean
        
        can be used to check different thread
        
        trdOb.interrupted()
        
        returns boolean
        
        resets flag to "no"
        
        can be used in infinite loops
    - - trdObj.join()
        
        joins executing thread
        with trdObj
        
        waits for trdObj to complete before
        proceeding to next line after .join()
  - - - thread interference
        
        different threads interfering with data processing of other threads
      - memory inconsistency
        
        unexpected values due to other threads interferance
    - - synchronized
        method
        
        happens-before relationship - for memory inconsistency
        
        no interleaving - for thread interference
        
        use the object's lock
        
        public synchronized void doMethod(){ ... }
      - synchronized
        statements
        
        specify an object for the lock
        
        exclude method call of other objects, avoid issue
        
        fine grained synchronization of unrelated variables w/in same method.
        
        synchronized(lockObj){ ... }
        synchronized(this){ ... }
        
        monitor lock
        
        all objects has one
        
        reentrant
        synchronization
        
        synchronized method/statement use same lock of calling sync method/statement
      - atomic actions
        
        read / write of reference and primitive except long and double
        
        all variables declared as volatile
        
        actions that happen completely or not at all
        
        public volatile long longVar = 3_000_000_000L
  - - - waiting for each other
    - - wont stop responding to each other
    - - long running process wont let others start
- - - - alternating / sharing processing time
  - - - private run-time resources
      - own memory area
    - - in same app
      - on different app
      - via Inter Process
        Communications IPC
        
        pipes
        
        sockets
    - - has at least "Main" thread
  - - - memory area
      - open files
      - communication
- - - - ReentractLock
        (class)
    - - lockObj.tryLock()
      - lockObj.lockInterruptibly()
      - lockObj.lock()
      - lockObj.unlock()
  - - - execServObj.submit( runnable / callable )
      - callable
        
        similar to runnable but returns a value
      - future
        
        returned by submit
        
        retrieves the return value of callable
      - subinterface of Executor
      - thread pools
        
        Executor static class
        
        creates ExecutorService objects
        
        that use worker threads
        
        Executors.newFixedThreadPool()
        
        Executors.newCachedThreadPool()
        
        Executors.newSingleThreadExecutor()
      - Fork / Join framework
        
        implement ExecutorService
        
        break down work into smaller pieces
        
        to use all available processing power
        
        work stealing algorithm
    - - schedule()
        
        executes callable/runnable after specified delay
      - scheduleAtFixedRate()
        
        executes at defined intervals repeatedly
      - subinterface of ExecutorService
    - - has single method
        
        execObj.execute(runnable)
      - replacement for common thread creation idiom