Learn multithreading and concurrency in Java with this quick, engaging course. Perfect for beginners seeking practical examples and skills.
This course gives you a quick, no-nonsense look at multithreading and concurrency in Java. It's all about understanding and managing threads, with quirky examples and practical exercises that make learning fun and effective.
A little treat with all you need to know about multithreading and concurrency in Java
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
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
1 Lectures
7 Lectures
3 Lectures
Loonycorn is us, Janani Ravi and Vitthal Srinivasan. Between us, we have studied at Stanford, been admitted to IIM Ahmedabad and have spent years  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...
it is very basic course for multi-threading, which you may already know, it is not in depth.
Love all classes by Loony Corn
The course is good to get started for folks who want to learn multi threading concepts.In terms of theory the concepts are cleared at intermediate multi threading. However advanced multi threading is not covered at all.
It would have been better if things like concurrent collections,countdown latch,cyclic barrier,lock,fork join and semaphore are included.
Videos related to livelock,stavation and deadlock would be good to have as this is one area practically real time projects face.
On the last page of the lecture the authors are wrong. They said that volatile variables are safe to be used by different threads, however it is not true.
Volatile makes sure other threads can see change made to counter but still has a race condition. pre/post-incrementation is not atomic!!
The only side effect of volatile is "flushing" caches so that all other parties see the freshest version of the data. This is too strict in most situations; that is why volatile is not default.
Apart from this the course explains the very very basics in java threads.
Kind of good, but not sufficient
Great Course
The instructor was really slow explaining the concept, it felt dragging and boring. The typing in slides or video was annoying and was not syncing with audio and felt frustrated. It would have been good if fundamentals would have been covered at faster pace and would have been accompanied by real life examples or use cases instead of theoretical examples. Instead of typing the text or having typing effect, the text should have appeared directly. The fundamentals explained were good. The comparisons made between native thread library and concurrent API's were useful. Hope instructor improves this course in future and acts over the suggestions.
Annoying hands, just simply just quoting obvious things. really bad teaching skills
because its good :-)
Your email address will not be published. Required fields are marked *
Balakrishna D.
Crisp content easy to follow and gain knowledge