Java Concurrency සහ Multi-threading සිංහලෙන්

ඔයා Java වල concurrency සහ multithreading ගැන මුල ඉඳලම සරලව ඉගෙන ගන්න කැමති නම්, මේ වීඩියෝ එක ඔයාට ගොඩක් වැදගත් වෙයි. අපි මේකේදී basic thread creation වල ඉඳලා advanced synchronization සහ concurrent collections වෙනකම් හැම දෙයක්ම real code examples එක්ක කතා කරනවා. මේක බැලුවට පස්සේ ඔයාට කිසිම බයක් නැතුව thread-safe Java applications ලියන්න පුළුවන් වෙයි.

අපි මේ වීඩියෝ එකෙන් කතා කරන දේවල් මෙන්න මේවා:

✅ Introduction to concurrency: ඇයි modern applications වලට මේක මෙච්චර වැදගත් වෙන්නේ?
🧠 Processes vs threads: මේ දෙකේ වෙනස සහ JVM එක මේවා manage කරන්නේ කොහොමද?
🚀 Java වල thread එකක් create කරලා start කරන්නේ කොහොමද?
⏸️ Thread එකක් sleep කරලා pause කරන්නේ කොහොමද සහ ඒකේ තියෙන pitfalls මොනවාද?
🔗 Joining a thread: වැඩ කරන order එක හරියට coordinate කරන්නේ කොහොමද?
⚡ Thread එකක් safe විදියට interrupt කරන්නේ කොහොමද?
🐞 Real-world code වලදී එන concurrency issues මොනවාද?
🎯 Race conditions නිසා code එක break වෙන්නේ කොහොමද?
🛡️ Thread safety සහ defensive design සඳහා පාවිච්චි කරන strategies.
📦 Thread confinement සහ shared state limit කරන විදිය.
🔐 වැඩි control එකක් ගන්න locks පාවිච්චි කරන්නේ කොහොමද?
🧱 Synchronized keyword එක සහ intrinsic locks ගැන.
👁️ Volatile keyword එක සහ visibility guarantees ගැන.
📣 Wait() සහ notify() පාවිච්චි කරලා thread signalling කරන්නේ කොහොමද?
⚙️ Atomic objects සහ lock-free operations කියන්නේ මොනවාද?
📈 Adders සහ high-concurrency counters පාවිච්චි කරන විදිය.
🗂️ Synchronized collections පාවිච්චි කළ යුතු වෙලාවන්.
🧩 java.util.concurrent ඇතුලේ තියෙන concurrent collections ගැන.
🏁 අන්තිමට ඔයාට වැඩ කරද්දී පාවිච්චි කරන්න පුළුවන් best practices ටිකක්.

මේ වීඩියෝ එක ඉවර වෙද්දී ඔයාට thread-safe code එකක් design කරන්නේ කොහොමද, සාමාන්‍යයෙන් එන concurrency bugs මග හරින්නේ කොහොමද සහ Java වල තියෙන concurrency API එක ඔයාගේ projects වලට හරියට පාවිච්චි කරන්නේ කොහොමද කියන එක ගැන හොඳ අවබෝධයක් ලැබෙයි.

ඉතින් මේ වීඩියෝ එකෙන් ඔයාට දෙයක් ඉගෙන ගන්න ලැබුණා නම්, වීඩියෝ එකට like එකක් දාලා, subscribe කරන්නත් අමතක කරන්න එපා. ඒ වගේම ඊළඟට ඔයා ඉගෙන ගන්න කැමති concurrency topics තියෙනවා නම් comment එකක් දාන්න!

Learn Java concurrency and multithreading step by step with real code examples, from basic thread creation to advanced synchronization and concurrent collections. This video (and mini-series) will take you from beginner to confident with writing thread-safe Java applications.

In this video, we cover:
Introduction to concurrency and why it matters in modern applications
Processes vs threads and how the JVM manages them
Creating and starting a thread in Java
Pausing a thread with sleep and understanding its pitfalls
Joining a thread and coordinating execution order
Interrupting a thread safely
Concurrency issues that appear in real-world code
Race conditions and how they break correctness
Strategies for thread safety and defensive design
Thread confinement and limiting shared state
Using locks for fine-grained control
The synchronized keyword and intrinsic locks
The volatile keyword and visibility guarantees
Thread signalling with wait() and notify()
Atomic objects and lock-free operations
Adders and high-concurrency counters
Synchronized collections and when to use them
Concurrent collections from java.util.concurrent
Final summary and best practices you can apply right away

By the end, you’ll understand how to design and implement thread-safe code, avoid common concurrency bugs, and use the Java concurrency API effectively in your projects.

If this helped you, don’t forget to like the video, subscribe, and leave a comment with any concurrency topics you’d like to see next.

Видео Java Concurrency සහ Multi-threading සිංහලෙන් канала Rusiru Gunaratne