HOME > Development > Java- Multi-threading and Concurrency Simplified

Java- Multi-threading and Concurrency Simplified

  • Development
  • Jan 03, 2025
SynopsisJava: Multi-threading and Concurrency Simplified, available a...
Java- Multi-threading and Concurrency Simplified  No.1

Java: Multi-threading and Concurrency Simplified, available at $59.99, has an average rating of 4.73, with 61 lectures, based on 1122 reviews, and has 26278 subscribers.

You will learn about Understand Thread concepts – Designing, States, Priorities, Daemon Threads. Apply concurrency control techniques using synchronized blocks and locks. Understand the key components of java.util.concurrent package including Fork Join Framework Mock a simple HttpServer interaction Kick start thinking in distributed way This course is ideal for individuals who are Any one who is looking to add Multithreading and concurrency to their skill set along with Java It is particularly useful for Any one who is looking to add Multithreading and concurrency to their skill set along with Java.

Enroll now: Java: Multi-threading and Concurrency Simplified

Summary

Title: Java: Multi-threading and Concurrency Simplified

Price: $59.99

Average Rating: 4.73

Number of Lectures: 61

Number of Published Lectures: 61

Number of Curriculum Items: 61

Number of Published Curriculum Objects: 61

Original Price: $39.99

Quality Status: approved

Status: Live

What You Will Learn

  • Understand Thread concepts – Designing, States, Priorities, Daemon Threads.
  • Apply concurrency control techniques using synchronized blocks and locks.
  • Understand the key components of java.util.concurrent package including Fork Join Framework
  • Mock a simple HttpServer interaction
  • Kick start thinking in distributed way
  • Who Should Attend

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

  • Any one who is looking to add Multithreading and concurrency to their skill set along with Java
  • 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.?

    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)

  • Course Curriculum

    Chapter 1: Introduction

    Lecture 1: Introduction

    Lecture 2: Single Threaded vs Multi Threaded Apps

    Lecture 3: Single Threaded App Example

    Lecture 4: Notes – Single Threaded App Example

    Lecture 5: True Parallelism vs Logical Parallelism

    Lecture 6: Notes – True Parallelism vs Logical Parallelism

    Chapter 2: Designing Multi-threaded applications

    Lecture 1: Designing Threads

    Lecture 2: Designing Threads Explained

    Lecture 3: Notes – Designing Threads

    Lecture 4: Transform code to achieve parallelism

    Lecture 5: Notes – Transform code to achieve parallelism

    Lecture 6: Executor Service

    Lecture 7: Notes – Executor Service

    Lecture 8: Stopping Thread in the middle

    Lecture 9: Notes – Stopping Thread in the middle

    Lecture 10: Thread States

    Lecture 11: Notes – Thread States

    Lecture 12: Thread Priorities

    Lecture 13: Notes – Thread Priorities

    Lecture 14: Internal System Threads and ThreadGroup

    Lecture 15: Notes – Internal System Threads and ThreadGroup

    Lecture 16: Daemon Threads

    Lecture 17: Notes – Daemon Threads

    Lecture 18: Callable Task

    Lecture 19: Notes – Callable Task

    Lecture 20: Pattern search in folder – Serial approach

    Lecture 21: Pattern search in folder – Parallel approach

    Lecture 22: Notes – Pattern Search in folder

    Lecture 23: Problem Set – 1

    Lecture 24: Problem Set – 1 – Solution

    Chapter 3: Concurrency Control

    Lecture 1: Need for Synchronization

    Lecture 2: Synchronized methods

    Lecture 3: Synchronized in case of static members

    Lecture 4: The Problem with Synchronized Method and Solution with Synchronized Block

    Lecture 5: Notes – Thread Synchronization

    Lecture 6: Deadlocks and solution with lock sequencing

    Lecture 7: Notes – Deadlocks and solution with lock sequencing

    Lecture 8: Reentrant Locks

    Lecture 9: Notes – Reentrant Locks

    Lecture 10: Problem Set – 2

    Lecture 11: Problem Set – 2 – Solution

    Lecture 12: Thread Signaling Using wait and notify

    Lecture 13: Producer and Consumer Problem

    Lecture 14: Notes – Producer and Consumer Problem

    Chapter 4: Mock HttpServer and ThreadLocal Pattern

    Lecture 1: HTTP and Mock multi-threaded HTTP Server

    Lecture 2: ThreadLocal

    Lecture 3: Notes – ThreadLocal

    Chapter 5: java.util.concurrent package

    Lecture 1: BlockingQueue and revised producer and consumer problem

    Lecture 2: Notes – BlockingQueue and revised producer and consumer problem

    Lecture 3: PriorityBlockingQueue

    Lecture 4: Notes – PriorityBlockingQueue

    Lecture 5: Fork Join Framework

    Lecture 6: Notes – Fork Join Framework

    Lecture 7: Semaphore

    Lecture 8: CountDownLatch

    Lecture 9: CyclicBarrier

    Lecture 10: Atomic Types (AtomicInteger, AtomicBoolean.)

    Chapter 6: Kick Start Thinking Distributed

    Lecture 1: Scale up using Queues

    Lecture 2: Heads up about Distributed Locks

    Chapter 7: Source Code

    Lecture 1: Source Code for download

    Chapter 8: Whats next?

    Lecture 1: Bonus Lecture: OFFER Coupons for my other courses

    Instructors

  • Java- Multi-threading and Concurrency Simplified  No.2
    Sagar Uppuluri
    Software Architect and a passionate trainer
  • Rating Distribution

  • 1 stars: 6 votes
  • 2 stars: 12 votes
  • 3 stars: 104 votes
  • 4 stars: 447 votes
  • 5 stars: 553 votes
  • Frequently Asked Questions

    How long do I have access to the course materials?

    You can view and review the lecture materials indefinitely, like an on-demand channel.

    Can I take my courses with me wherever I go?

    Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!