Concurrency, Multithreading And Parallel Computing In Java

Multithreading and Concurrent Programming, Parallel Computation and MapReduce in Java + Fork-Join and Stream API

What you'll learn

Understand basic concurrency

Understand the basics of multithreading

Understand parallel processing

Able to use the concepts in real life scenarios

Understand concurrent collections

Understand synchronization and locking

Understand the Fork-Join Framework

Understand Stream API

Requirements

Basic Java (inheritance, object oriented programming)

Description

This course is about the basics of multithreading and concurrent programming with some parallel concepts. In the 21st century this topic is becoming more and more popular with the advent of Big Data and Machine Learning. We will consider the low level concepts such as threads, synchronization and locks. The second chapter will be about concurrent library: of course there are built in classes and interfaces that we can use when implementing multithreaded applications. Then we develop little programs as show-cases for multithreading: the dining-philosopher problem and the students in library simulation. Last chapter is about parallel computing and MapReduce. Section 1 - Multithreading Theory:theory behind multithreadingpros and cons of multithreadinglife cycle of a theadSection 2 - Threads Manipulation:starting threads (Runnable interface and Thread class)join keyworddaemon threadsSection 3 - Inter-Thread Communication:memory management of threadssynchronization and synchronized blockslockswait and notifyproducer-consumer problem and solutionconcurrent collectionslatch, cyclic barrier and blocking queuesdelay queue, priority queue and concurrent mapsSection 4 - Multithreading Concepts:volatile keywordsdeadlocks and livelockssemaphores and mutexesdining philosophers problemlibrary applicationSection 6 - Executors and ExecutorServices:executorsexecutor servicesSection 6 - Concurrent Collections:synchronization with Collectionslatchescyclic barriersdelay and priority queuesconcurrent HashMapsCopyOnWriteArrayListsSection 7 -  Simulations:dining philosophers problemlibrary problemSection 8 - Parallel Algorithms:what is parallel computingparallel merge sortparallel algorithmsSection 9 - Fork-Join FrameworkFork-Join frameworkmaximum finding in parallel mannerSection 10 - Stream APIthe Stream API explained with examplessequential streams and parallel streamsSection 11 - BigData and MapReduce:what is MapReduceMapReduce and Fork-Join frameworkThanks for joining my course, let's get started!

Overview

Section 1: Introduction

Lecture 1 Introduction

Section 2: ### MULTITHREADING ###

Lecture 2 Multithreading section

Section 3: Multithreading Theory

Lecture 3 Processes and threads introduction

Lecture 4 What is time-slicing algorithm?

Lecture 5 Benefits of multithreading

Lecture 6 Downside of multithreading

Lecture 7 Thread lifecycles

Section 4: Threads Manipulation

Lecture 8 Sequential processing

Lecture 9 Starting threads - Runnable

Lecture 10 Starting threads - Thread class

Lecture 11 Runnable interface and Thread class

Lecture 12 Wait for threads to finish - join

Lecture 13 Daemon threads and user threads

Lecture 14 Thread priority and Java Thread Scheduler

Section 5: Inter-Thread Communication

Lecture 15 Memory management of threads

Lecture 16 Synchronization

Lecture 17 Problems with synchronization

Lecture 18 Locking with custom objects

Lecture 19 What are re-entrant locks?

Lecture 20 Wait and notify

Lecture 21 What is the difference between wait and sleep?

Lecture 22 Producer and consumer

Lecture 23 Locks

Lecture 24 Producer consumer with locks

Lecture 25 Locks and synchronization

Section 6: Multithreading Concepts

Lecture 26 Volatile

Lecture 27 Stopping a thread

Lecture 28 Deadlock and livelock

Lecture 29 Deadlock example

Lecture 30 Livelock example

Lecture 31 Atomic variables

Lecture 32 What are semaphores?

Lecture 33 Mutexes and semaphores

Lecture 34 Semaphores example

Lecture 35 Mutex and binary semaphore

Section 7: Creating Threads with Executors

Lecture 36 Why to use thread pools?

Lecture 37 Executors example - SingleThreadExecutor

Lecture 38 Executors example - FixedThreadPools

Lecture 39 Executors example - ScheduledExecutor

Lecture 40 Stopping executors

Lecture 41 What is a Callable interface and Future object?

Lecture 42 Callable and future example

Section 8: Concurrent Collections

Lecture 43 What is the collections framework?

Lecture 44 Collections synchronization

Lecture 45 Latch

Lecture 46 Cyclic barrier

Lecture 47 Blocking queue

Lecture 48 Delay queue

Lecture 49 Priority queue

Lecture 50 Concurrent maps

Lecture 51 Exchanger

Lecture 52 CopyOnWriteArrays

Section 9: Multithreading Exercise I - Dining Philosophers Problem

Lecture 53 Dining philosophers problem I - the problem

Lecture 54 Dining philosophers problems II - constants

Lecture 55 Dining philosophers problems III - chopstick

Lecture 56 Dining philosophers problems IV - philosopher

Lecture 57 Dining philosophers problems V - starting the threads

Lecture 58 Dining philosophers problems VI - running the simulation

Section 10: Multithreading Exercise II -Students Library Problem

Lecture 59 Student library simulation I - the problem

Lecture 60 Student library simulation II - constants

Lecture 61 Student library simulation III - book

Lecture 62 Student library simulation IV - student

Lecture 63 Student library simulation V - lock() and tryLock()

Lecture 64 Student library simulation VI - running the simulation

Section 11: ### PARALLEL ALGORITHMS ###

Lecture 65 What is parallel computing?

Section 12: Parallelization

Lecture 66 Sequential merge sort introduction

Lecture 67 Sequential merge sort implementation

Lecture 68 Merge sort and stack memory visualization

Lecture 69 Parallel merge sort implementation

Lecture 70 Running time comparison of merge sort implementations

Lecture 71 Sum problem introduction

Lecture 72 Sum problem - sequential approach

Lecture 73 Sum problem - parallel implementation

Lecture 74 Running time comparison of sum operations

Section 13: Fork-Join Framework

Lecture 75 What is the Fork-join framework?

Lecture 76 Fork-join framework simple example - RecursiveAction

Lecture 77 Exercise - printing integers

Lecture 78 Solution - printing integers

Lecture 79 Fork-join framework simple example - RecursiveTask

Lecture 80 Exercise - Fibonacci-numbers

Lecture 81 Solution - Fibonacci-numbers

Lecture 82 Thread optimization

Lecture 83 Maximum finding - the algorithm

Lecture 84 Maximum finding - running the application

Lecture 85 Merge sort revisited I

Lecture 86 Merge sort revisited II

Section 14: Using Java's Stream API

Lecture 87 What is the Stream API?

Lecture 88 Streams with numbers

Lecture 89 Streams with strings

Lecture 90 Collections and streams

Lecture 91 Streams with custom objects - part 1

Lecture 92 Streams with custom objects - part 2

Lecture 93 Exercise - filtering

Lecture 94 Solution - filtering

Lecture 95 External and internal iteration

Lecture 96 Processing files with streams

Lecture 97 Short-circuiting and loop fusion

Lecture 98 map() and flatMap()

Lecture 99 Exercise - mapping

Lecture 100 Solution - mapping

Lecture 101 Optionals and other important concepts

Lecture 102 OptionalInt, OptionalFloat and OptionalDouble

Lecture 103 allMatch(), noneMatch(), findFirst() and findAny()

Lecture 104 Parallelization - example #1

Lecture 105 Parallelization - example #2

Lecture 106 Parallelization - example #3

Section 15: MapReduce and Parallelization

Lecture 107 MapReduce introduction - basics

Lecture 108 MapReduce introduction - example

Lecture 109 MapReduce and Fork-Join

Section 16: Course Materials (DOWNLOADS)

Lecture 110 Course materials

This course is meant for students who want to get a good grasp on multithreading in java or just want a quick refresher