Multi threading in Java is the most essential feature that each and every Java developer should understand and be able to confidently apply it in solving complex programming problems where concurrent execution is a must. With parallel processing there comes a risk, i.e. shared mutability and the ability of the developer to solve concurrency problems. 

Description

Thanks to the Java programming language that it makes the mighty multi-threaded application development a cake walk, if you assimilate few keys or core concepts you will be able to confidently design multi threaded applications with ease.

To design multi threaded applications developers need to look at it through a different perspective i.e. change the thinking from serial to parallel and it requires some effort. Keeping this in mind this course contains the essential lectures which can guide you in this regard.

This course was designed keeping the above points in mind and will help you understand these complex problems through simplified and easy to understand examples. 

Course contents include

• Understanding Threads, Priorities, States, Daemon Threads.

• Thread synchronization using synchronized blocks and locks.

• Key components of java.util.concurrent package including ForkJoinPool and ForkJoinTask(s).

• Mock HttpServer to explain how HTTP works and simulate how a typical web server responds to the client requests.

• ThreadLocal

• Introduction to distributed locks

• An overview of how to build scalable applications using Messaging Queues.

• Introduction to Lambdas and Streams (Coming up)

• Any one who is looking to add Multithreading and concurrency to their skill set along with Java

Course content

• Introduction
  • Introduction
  • Single Threaded vs Multi Threaded Apps
  • Single Threaded App Example
  • Notes - Single Threaded App Example
  • True Parallelism vs Logical Parallelism
  • Notes - True Parallelism vs Logical Parallelism
• Designing Multi-threaded applications
  • Designing Threads
  • Designing Threads Explained
  • Notes - Designing Threads
  • Transform code to achieve parallelism
  • Notes - Transform code to achieve parallelism
  • Executor Service
  • Notes - Executor Service
  • Stopping Thread in the middle
  • Notes - Stopping Thread in the middle
  • Thread States
  • Notes - Thread States
  • Thread Priorities
  • Notes - Thread Priorities
  • Internal System Threads and ThreadGroup
  • Notes - Internal System Threads and ThreadGroup
  • Daemon Threads
  • Notes - Daemon Threads
  • Callable Task
  • Notes - Callable Task
  • Pattern search in folder - Serial approach
  • Pattern search in folder - Parallel approach
  • Notes - Pattern Search in folder
  • Problem Set - 1
  • Problem Set - 1 - Solution
• Concurrency Control
  • Need for Synchronization
  • Synchronized methods
  • Synchronized in case of static members
  • The Problem with Synchronized Method and Solution with Synchronized Block
  • Notes - Thread Synchronization
  • Deadlocks and solution with lock sequencing
  • Notes - Deadlocks and solution with lock sequencing
  • Reentrant Locks
  • Notes - Reentrant Locks
  • Problem Set - 2
  • Problem Set - 2 - Solution
  • Thread Signaling Using wait and notify
  • Producer and Consumer Problem
  • Notes - Producer and Consumer Problem
• Mock HttpServer and ThreadLocal Pattern
  • HTTP and Mock multi-threaded HTTP Server
  • ThreadLocal
  • Notes - ThreadLocal
• java.util.concurrent package
  • BlockingQueue and revised producer and consumer problem
  • Notes - BlockingQueue and revised producer and consumer problem
  • PriorityBlockingQueue
  • Notes - PriorityBlockingQueue
  • Fork Join Framework
  • Notes - Fork Join Framework
• Kick Start Thinking Distributed
  • Scale up using Queues
  • Heads up about Distributed Locks
• Source Code
  • Source Code for download
• Conclusion
  • Bonus Lecture: Next Steps