Android Multithreading Masterclass

Android Multithreading Masterclass, available at $119.99, has an average rating of 4.63, with 81 lectures, based on 1002 reviews, and has 5948 subscribers.

You will learn about Write multithreaded code of any complexity in your Android apps Learn the difference between the UI and background threads Understand advanced concepts like Synchronization, Locks, Volatility and Happens-Before Analyze and reason about the thread-safety of your code Manage hundreds of inter-dependent threads Prevent memory leaks Compare popular concurrency frameworks for Android: AsyncTask, RxJava, Coroutines This course is ideal for individuals who are Android developers It is particularly useful for Android developers.

Enroll now: Android Multithreading Masterclass

Summary

Title: Android Multithreading Masterclass

Price: $119.99

Average Rating: 4.63

Number of Lectures: 81

Number of Published Lectures: 81

Number of Curriculum Items: 81

Number of Published Curriculum Objects: 81

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

Write multithreaded code of any complexity in your Android apps
Learn the difference between the UI and background threads
Understand advanced concepts like Synchronization, Locks, Volatility and Happens-Before
Analyze and reason about the thread-safety of your code
Manage hundreds of inter-dependent threads
Prevent memory leaks
Compare popular concurrency frameworks for Android: AsyncTask, RxJava, Coroutines

Who Should Attend

Android developers

Target Audiences

Android developers

Multithreading is an essential topic in Android development because, to write snappy and reliable Android applications, you must use more than one thread. Unfortunately, multithreading is also a very complex technique that introduces unique challenges. Incorrect multithreaded code manifests itself as unresponsive user interfaces, freezes, memory leaks, crashes and other bugs, all of which can be very challenging to find and fix.

In this course, you’ll dive into the fundamentals of multithreading and learn to write correct and performant multithreaded code of any complexity in your Android applications!

Topics covered in this course:

What a thread is
Why multithreading is uniquely challenging
Keep the user interface responsive
Make your multithreaded code thread-safe (i.e. correct and reliable)
Analyze the performance of multithreaded code
Manage up to hundreds(!) of concurrent threads
Compare several multithreading frameworks for Android, including AsyncTask, RxJava and Kotlin Coroutines
More…

You’ll practice everything you’ll learn here by solving a series of carefully designed, hands-on exercises. So, after completing this course, you’ll have extensive hands-on experience with multithreaded code.

We’ll review several popular concurrency frameworks and see how they accommodate the same complex multithreaded feature. This will allow you to grasp the full landscape of multithreading in Android ecosystem. This will allow you to choose the framework you like the best to use in your Android projects!

So, if you want to become an expert in Android multithreading, this course is perfect for you!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Java and Kotlin

Lecture 2: Tutorial Application Overview and Important Info

Chapter 2: Concurrency and Multithreading Fundamentals

Lecture 1: Motivation for Hardware Intuition

Lecture 2: CPU Operation Basics

Lecture 3: Single-Tasking System

Lecture 4: Cooperative Multitasking System

Lecture 5: Preemptive Multitasking System

Lecture 6: Multiprocessing System

Lecture 7: Android Processes and Threads

Chapter 3: Thread Class, Garbage Collector, Memory Leaks

Lecture 1: java.lang.Thread Class

Lecture 2: Exercise 1

Lecture 3: Garbage Collector in Android

Lecture 4: Memory Leaks in Android

Lecture 5: Threads Termination

Lecture 6: Exercise 2

Lecture 7: Thread Class, Garbage Collector, Memory Leaks Summary

Chapter 4: UI Thread in Android Applications

Lecture 1: UI Thread vs Background Thread in Android

Lecture 2: Demonstration of UI Thread

Lecture 3: User Interface Responsiveness

Lecture 4: Protection of User Interface from Background Threads

Lecture 5: Execution of Code on UI Thread

Lecture 6: Handler and Looper Intuition

Lecture 7: Exercise 3

Lecture 8: UI Thread in Android Applications Summary

Chapter 5: Multithreading Challenges

Lecture 1: Introduction To Multithreading Challenges

Lecture 2: Visibility

Lecture 3: Atomicity

Lecture 4: Volatile Variables

Lecture 5: Concurrency Bug Fix, or When Volatility Isn't Sufficient

Lecture 6: Atomic Classes

Lecture 7: Threads Synchronization

Lecture 8: Immutability

Lecture 9: Happens Before

Lecture 10: Happens Before Demonstration

Lecture 11: Exercise 4

Lecture 12: Exercise 4 Solution

Lecture 13: Amendment to Exercise 4 Solution

Lecture 14: Multithreading Challenges Summary

Chapter 6: Paused (Blocked) Threads

Lecture 1: Pausing Threads

Lecture 2: Thread Sleep

Lecture 3: Thread Wait

Lecture 4: Thread Join

Lecture 5: Amendment To Thread Join

Lecture 6: Exercise 5

Lecture 7: Solution Exercise 5

Lecture 8: Paused (Blocked) Threads Summary

Chapter 7: Clean Design of Multithreaded Code

Lecture 1: Importance of Clean Design

Lecture 2: Refactoring to Use Case and Observer

Lecture 3: Java 8 Lambdas

Lecture 4: Exercise 6

Lecture 5: Clean Design of Multithreaded Code Summary

Chapter 8: Thread Pool

Lecture 1: Simple Cached Thread Pool

Lecture 2: Thread Pool Issues

Lecture 3: Custom Configuration Of ThreadPoolExecutor

Lecture 4: Interplay Between Core Threads and Keep Alive Time

Lecture 5: Misconfiguration of ThreadPoolExecutor in AsyncTask

Lecture 6: Providing Multithreading Classes Using Dependency Injection

Lecture 7: Exercise 7

Lecture 8: Thread Pool Summary

Chapter 9: AsyncTask

Lecture 1: Why You Need to Know AsyncTask

Lecture 2: AsyncTask Demonstration and Highlight of Issues

Lecture 3: AsyncTask Summary

Chapter 10: ThreadPoster

Lecture 1: ThreadPoster Demonstration

Lecture 2: Exercise 8

Lecture 3: ThreadPoster Summary

Chapter 11: RxJava

Lecture 1: RxJava Introduction

Lecture 2: RxJava Observable

Lecture 3: RxJava Disposable

Lecture 4: RxJava Advanced Multithreading

Lecture 5: Exercise 9

Lecture 6: RxJava Summary

Chapter 12: Coroutines

Lecture 1: Kotlin and Corooutines

Lecture 2: Coroutines Demonstration

Lecture 3: Nested Coroutines

Lecture 4: Coroutines Dispatchers

Lecture 5: Coroutines Cancellation

Lecture 6: Non Cancellable Coroutines

Lecture 7: Exercise 10

Lecture 8: Coroutines Summary

Chapter 13: Course Summary and Next Steps

Lecture 1: Summary

Lecture 2: Bonus Lecture

Instructors

Vasiliy Zukanov
Professional Android developer, Blogger, Educator

Rating Distribution

1 stars: 4 votes
2 stars: 14 votes
3 stars: 48 votes
4 stars: 245 votes
5 stars: 691 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!

Menu