Byte Size Chunks : Java Multithreading
4.1 (21 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
186 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Byte Size Chunks : Java Multithreading to your Wishlist.

Add to Wishlist

Byte Size Chunks : Java Multithreading

A little treat with all you need to know about multithreading and concurrency in Java
4.1 (21 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
186 students enrolled
Created by Loony Corn
Last updated 11/2015
English
Current price: $10 Original price: $20 Discount: 50% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 2.5 hours on-demand video
  • 12 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?
What Will I Learn?
Manage concurrency and threading issues in a multi-threaded environment
Use (and debug!) Java threading support - both old (runnables) and new (callables, futures)
Identify, detect and prevent all common concurrency bugs
Use and truly understand the synchronized keyword
View Curriculum
Requirements
  • This course calls for a basic working knowledge of Java
Description
  • Prerequisites: Basic understanding of Java
  • Taught by a Stanford-educated, ex-Googler, husband-wife team
  • Please don't take this class if you have already signed up for our From 0 to 1: Learn Java Programming course (that includes a far longer and more in-depth version of this material)

This is a quick and handy course with exactly what you need to know (nothing more, nothing less!) about multithreading and concurrency in Java

Let’s parse that.

  • The course is quick and handy: It explains multithreading and concurrency in Java in just the right level of detail for you to put these to work today.
  • The course has exactly what you need - nothing more, nothing less. It starts from zero, builds up the design, then gives plenty of real-world examples, but crisply and quickly.
  • The course is also quirky. The examples are irreverent. Lots of little touches: repetition, zooming out so we remember the big picture, active learning with plenty of quizzes. There’s also a peppy soundtrack, and art - all shown by studies to improve cognition and recall.

What's covered:

  • Context: Why threading matters, and why it is getting more important as CPU architectures evolve and cloud-computing catches on
  • The basics: threads, processes, shared memory and inter-thread communcation
  • Old-school Java threading: Runnable and Thread objects and using them
  • New-age Java threading: Callable and Future objects, executors and other services
  • Semantics: the synchronized and volatile keywords
  • Case study: Double-checked locking and the singleton pattern
Who is the target audience?
  • Yep! Folks who know some Java but are entirely new to multi-threading or writing concurrent code
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 13 Lectures Collapse All 13 Lectures 02:22:57
+
Introduction
1 Lecture 02:17

We'll start with an introduction, what this course is about and what you should know at the end of the course.

Preview 02:17
+
Threading and Concurrency: A Lot Going On All At Once
7 Lectures 01:24:06

As computers have become multi-core, and then as cloud computing has taken off, the importance of threading has increased substantially. This lecture is an introduction to the concept of threading which allows programmers to do different things simultaneously. We will also discuss the differences between processes and threads, old school concepts vs new school concepts in threads and some use-cases of threads.

Preview 14:10

We'll talk about a specific use case for threading where spinning off multiple threads can give us huge performance gains. Java support for threading is great even in its traditional form. New libraries however, make working with threads far easier.

Threading: Old school vs New school
11:57

We study threading the way it has traditionally been done in Java - the Runnable interface; extending the Thread class; join(), sleep() and thread interrupts.

Traditional Threading Support
14:18

Multi-threading involves concurrent execution of threads, and this gives rise to an entire range of potential issues: thread interference, memory consistency and thread contention.
Threading and Concurrency: A lot going on at once
11:28

Methods can be marked as synchronized - we study the nuances of doing so. We also examine threading issues such as livelock, deadlock and starvation.

Synchronized Methods, Livelock, Deadlock and Starvation
10:38

Let's figure out how to set up a multi-threaded program - and while doing so, we also encounter our first synchronization bug. We congratulate ourselves - wrestling with synchronization bugs is the badge of a serious programmer!
Working with threads - and our first synchronization bug!
15:38

We continue with our drill, and use our first lock. We learn yet another important thread-related lesson - that static variables can not be locked using the synchronized keyword.

Threads: Object locking and static variables in action
05:57

Threading
1 question

Threading
1 question

Threading
1 question
+
New School Threading with Callables and Futures
3 Lectures 34:11

In this lecture, we will talk about new features of Java which significantly improves its support for concurrency - the Callable interface,executors,thread pools, lock objects, concurrent collections and atomic variables. We will show how these new features make multi-threading a lot more robust.

Digging Deeper into Callables and Futures
15:21

We go back and reprise our threading drill, but this time we do so using the new threading framework - Callables instead of Runnables, and Executors instead of the Thread objects, and Future objects to retrieve the results.

Threading: New school fun in action
12:49

We now delve into the power of the new threading features - a CompletionService, for instance, which allows us to retrieve results from threads in the order in which they complete.

Threading: Executors are pretty cool
06:01

New-School Threading
1 question

New-School Threading
1 question
+
The Singleton Design Pattern
2 Lectures 22:23

The Singleton Pattern is beautiful - a unique object, usually implemented via a private constructor and a static getter method.

The Singleton Design Pattern Introduction
09:06

The Singleton Pattern is very elegant in its construction, but there are important nuances that we should be aware of, specifically related to multi-threading and to class loaders in Java. In this lecture, we explore how a concurrency-related Design Pattern called Double-Checked Locking can come in handy while implementing the Singleton in a multi-threaded environment.

The Singleton Design Pattern: Double-Checked Locking
13:17
About the Instructor
Loony Corn
4.3 Average rating
3,245 Reviews
25,834 Students
65 Courses
A 4-person team;ex-Google; Stanford, IIM Ahmedabad, IIT

Loonycorn is us, Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh. Between the four of us, we have studied at Stanford, IIM Ahmedabad, the IITs and have spent years (decades, actually) working in tech, in the Bay Area, New York, Singapore and Bangalore.

Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft

Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too

Swetha: Early Flipkart employee, IIM Ahmedabad and IIT Madras alum

Navdeep: longtime Flipkart employee too, and IIT Guwahati alum

We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!

We hope you will try our offerings, and think you'll like them :-)