I'm going through this playlist to learn Java concurrency, and I have to say your explanation and presentation quality are amazing, and the diagrams are really helpful. thank you!
I tried multiple times myself to understand JMM, But this is the first time i got to learn something about them. Excellent Presentation. Hats of to you, You define perfection!!
Started watching thread pool videos Nd then addicted to all of ur videos Nd subscribed..the way of explanation is precise , innovative Nd interesting.your wrk deserves more than a thnks..
My takeaway - if the tasks perform blocking IO operation, I should not use fork join pool. so true. Thanks for the explanation! You have a gift of mixing complicated concept easy to digest!
future me: volatile has semantics for memory visibility. Basically, the value of a volatile field becomes visible to all readers (other threads in particular) after a write operation completes on it. Without volatile, readers could see some non-updated value.
This playlist you have made is too awesome. your example/explanation for happens-before has a few issues. Not sure if I understood wrong, otherwise.Thank you so much for this playslit.
Hey great videos as always! I just wanted to ask, since primitives are passed by value and Objects are passed as reference, does the JVM only cache primitives into a threads local cache? If the value being updated was an Integer Object, e.g. new Integer(1), it would not need flushing as the object is passed by REFERENCE?
Wow…. Such an well articulated video. I felt this topic to be very difficult to understand before I watched your video. Please sir keep adding more and more topics to this channel. For the first time fell in love with subject videos.
I have been going through a lot of JAVA topic videos in different forums, by far Defog Tech is the best that I have come across. Advanced topics explained in a simple way which provides clarity. Keep going
🙏 You are the Best Teacher that I have ever seen.🥇, A classical method of approach = Superb indeed.👌.🎯Please Could you kindly teach us Flutter & Dart & Go lang & Scala too . Pleeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeese Sir..... 🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏
I am really amazed sir by your knowledge. Can you please share how you plan and learn all these things/concepts? Do you require them all these in your office related work regularly? I have been in IT industry for around 4-5 years but literally never faced these things, therefore never felt the need either to learn these. Please share some suggestions as senior developers to juniors on learning paths.
Exactly my feelings after been in the industry for a couple of decades. Learning from experience when applying concepts to real life work enhances understanding of concepts to the next level, something that prevail for years. I would be interested to know from Deepak, how he went about approaching concepts.
2:10 each core has its own cache and then there are shared caches. Thread running on core changes the variable in its local cache only, volatile keyword makes sure variable is flushed to shared cache when thread changes it so that changes are visible to all the other threads 6:05 happens before relationship 9:30 volatile keyword example
Hi can you help me I am confused when i was trying real time as per the diagram in the time 00:03:52 here i used this... System.out.println("the writerThread x is: "+x); System.out.println("the readerThread r2 is:"+r2); --------------------------------------------------------------------------------------------------------------------------------- like in this program(below): public class FieldVisibility { int x = 0; public void writerThread() { x = 1; System.out.println("the writerThread x is: "+x); } public void readerThread() { int r2 = x; System.out.println("the readerThread r2 is:"+x); } } output is:-- the writerThread x is: 1 the readerThread r2 is:1 ....................................................................................... instead of the writerThread x is: 1 the readerThread r2 is:0
Crystal clear explanation!!! thanks a million .. I observed that the code was working fine though i had not used the volatile keyword at 9:37. what could it be the reason ?
Hi, I have one request if you could make a video on Performance improvement techniques. Not necessarily related to threading but in general. I am sure everyone would be benefited as you explain complex things in very simple way :)
At 7:01 in video, x is volatile. But not a b or c. Will they also pushed back to main memory along with x? later in the same video you showing synchronise / locks for all fields
Hi, Thanks for the video. How is the volatile or synchronized or lock usage different from having the field in the constructor? Can't the shared cache object be used by putting the field in the constructor method and calling it in different threads?
But in multithreaded environment u can not be sure about which thread will get chance though we can override thread schedules behavior by setting priority...so in this case we need synchronization? My another questions is when thread executes the run method is it the only method thread executes then what about about synchronized blocks and synchronized methods...do we need to write those inside run method.... please clear my doubts..
Its difficult to ensure one thread is scheduled before another even in case of priority (eg: if CPU is multi-core, both low and high priority threads can be scheduled together). So its better to code using concurrency utilities (eg: Latches, Semaphores, volatiles etc.) Yes, most of the code that we want to run in a separate thread (as opposed to main thread) needs to be in run or call methods of Runnable/Called. Though, in Java 8, CompletableFuture or other frameworks/libraries could take your code in Supplier/Function/or any form, and run it within runnable without us knowing about it.
Very clear video, though I would like suggest you to fix the code examples of locks or at least to have a disclaimer by voice that no one should use locks by your examples and should read a documentation instead which says you have to use "try { .. } finally { lock.unlock(); }" construct.
Late comer :) Question: How at 9:03 locks will result in maintaining the variables a,b,c,x being atomic? The locks are for methods, which I understand as, no other there can enter in THAT method, but if some other methods are executed, then you may get the stale data. Isn't it?
In my case there is concurrent hashmap obj that holds configurations read from different server. Quartz scheduler will fetch configuration data for every 30 sec and update a new data (whole obj) to this concurrent hashmap.. In this case ,in my opinion voltaile should be used to always get the updated obj to the reader threads but some quality checking tools raising it as bug So any suggestions during this scenario
very very good explanation, it shows you have studied very hard , Hats off to you. But I will be very happy if you provide good working example to show difference between with volatile and without volatile, because when I try to find out difference using volatile and without volatile I do not notice anyone. your example in video do not demonstrate difference when I try it myself. thanks
Correct, so without volatile JVM doesn't guarantee other threads will see updated value. But it depends on speed of your operations, JVM implementation etc. Thus like for most concurrency issues it will work on local, will work in production for few days but might fail suddenly after
Yes you are correct, when I run my program again and again so many times then at some time situation arises and my volatile variable and non volatile variable get different values. I will be happy to share program to you. thanks
@DefogTech At time 8:47 How we are saying that value of all 4 variable will get updated while reading in readerThread because You are saying that X is not volatile. ?? As per first video of Volatile ,In this it was said that volatile values gets updated in Cache and because of that we are able to get updated value in different thread. Please help in this..
Updates to variables are visible to other threads by using any one of the options, volatile, synchronized or locks. Thus if you are using synchronized, even if variable is not volatile, updates will still be visibile to other threads.
how we can test compiler optimise our code. Ex : a = 3; b = 2; a = a + 1 to a = 3; a = a + 1; b = 2 i wrote this code, compiled and check class file. but when it decompile same instruction appeared. so how we can prove that, compier optimise our code.
Hi dude, Love your explanations. I have a doubt though. The visibility problem that you have mentioned in this video using the boolean flag- my question is from that area. Is the problem of visibility in the flag question a mere chance or is a must case. Like if I don't use volatile in the flag, is it like in every scenario my code will get into an infinite loop in thread 1, despite the update done by thread 2 on the flag; or is it like may happen in certain scenarios and may not happen in others? Thanks for your clear explanations.
Great video! Would it be possible to showcase when this happens? I've tried to replicate the issue with creating 2 new threads, however they seem to read x perfectly fine.
Sure, so it is possible that JVM will show the updated value to the other thread even though it is not say volatile, but, it is not guaranteed. In certain cases it can choose to keep using cached value. With volatile and other JMM rules we can be 100% sure that read-after always works. Can you share your code please. I can take a look
Check this code gist.github.com/DeepakVadgama/fdd282d9b10794ed21867dc912bafffd Try calling reader and writer methods, instead of reader2 and writer2. One uses atomicInteger, other uses int. In the output, int shows inconsistent results, while atomicInteger one prints in correct order.
Could you make a samples of reactive programming followed by your aka Java fiber videos. For eg, How to use RxJava for the below categories of apps, 1. Considering both frontend and backend 2. Considering there is no frontend and it's purely backend app. Doing good job. Really great👍
Hi I tried this fuctionality as you explained , Even if i keep as regular boolean instead of adding volatile, still the execution stops at some point. It does not run forever. Below is the example. Can you please explain why. package java8.labdaexp; public class VoltatileVisibility { boolean flag=true; public void writerThread() { System.out.println("Write operation"); flag =false; }
public void readerThread() { while (flag) { System.out.println("Read operation"); } } }
It may or may not happen. We cannot control the flush if we don't use volatile keyword. But if we use volatile keyword, it's guaranteed that the update will be flushed.
in most cases even without volatile the value is updated, but as per the spec JVM can choose to not show updates to other threads for perf or similar reasons. Using volatile is a guarantee given by spec itself.
Hi can you help me I am confused when i trying the output as per the diagram in the time 00:03:52 here i used this... System.out.println("the writerThread x is: "+x); System.out.println("the readerThread r2 is:"+r2); --------------------------------------------------------------------------------------------------------------------------------- like in this program(below): public class FieldVisibility { int x = 0; public void writerThread() { x = 1; System.out.println("the writerThread x is: "+x); } public void readerThread() { int r2 = x; System.out.println("the readerThread r2 is:"+x); } } output is:-- the writerThread x is: 1 the readerThread r2 is:1 ....................................................................................... instead of the writerThread x is: 1 the readerThread r2 is:0
I think that the example with "a,b,c,x" is wrong. The program order is not the code order thus d1, d2 and d3 can be zeroes even when "x" is synchronized.
As per the JVM specification, any variables written to before synchronization by one thread, will be visible (updated values) to other threads using same synchronization. Thus even if a,b,c are not used for synchronization itself, their updated values are still visible to the other thread
I'm going through this playlist to learn Java concurrency, and I have to say your explanation and presentation quality are amazing, and the diagrams are really helpful.
thank you!
Wow, thanks!
@@DefogTech Why no videos from you😔?? All your subscribers are waiting
I would absolutely recommend all Java engineers-whether junior or very senior-to watch this!
I tried multiple times myself to understand JMM,
But this is the first time i got to learn something about them.
Excellent Presentation.
Hats of to you, You define perfection!!
I am far from perfect. Though, thanks much for the kind words sir!
May be you should read java language specification : docs.oracle.com/javase/specs/jls/se8/html/jls-17.html .
I have never seen such an excellent explanation of JMM. Thanks a lot
Always read these topic therotically, but could never visualise it like this you have explained..Great presentation man!
The best video i could find on youtube.
Started watching thread pool videos Nd then addicted to all of ur videos Nd subscribed..the way of explanation is precise , innovative Nd interesting.your wrk deserves more than a thnks..
Thank you for the kind words!! I am so happy its helping everyone
Yes are techie by heart
Awesome video...Please don't stop making such excellent videos.
Thank you for the motivation sir!
Please make more videos
Defog Tech More videos :)
More videos pleaseeeee
My takeaway - if the tasks perform blocking IO operation, I should not use fork join pool. so true. Thanks for the explanation! You have a gift of mixing complicated concept easy to digest!
future me:
volatile has semantics for memory visibility. Basically, the value of a volatile field becomes visible to all readers (other threads in particular) after a write operation completes on it. Without volatile, readers could see some non-updated value.
Your explanations are precise, but have so in-depth/hidden informations and moreover so easy to understand
I had an interview question like that.. This is a very clean explanation , keep doing it!
Man, you are awesome. I was struggling trying to understand atomic operations and the use cases of volatile variables. Thank you so much
This helped me understand a lot about the JVM Thanks, you're very good at explaining things without any unneeded gibberish!
You have a good teacher in you. Please continue the good work.
This playlist you have made is too awesome. your example/explanation for happens-before has a few issues. Not sure if I understood wrong, otherwise.Thank you so much for this playslit.
Best video on java on whole TH-cam universe
Please make a whole course...I will definitely try buying it.Your videos are just awesome.
this channel deserve much more subscribers.
Hey great videos as always! I just wanted to ask, since primitives are passed by value and Objects are passed as reference, does the JVM only cache primitives into a threads local cache? If the value being updated was an Integer Object, e.g. new Integer(1), it would not need flushing as the object is passed by REFERENCE?
Wow…. Such an well articulated video. I felt this topic to be very difficult to understand before I watched your video. Please sir keep adding more and more topics to this channel. For the first time fell in love with subject videos.
I have been going through a lot of JAVA topic videos in different forums, by far Defog Tech is the best that I have come across. Advanced topics explained in a simple way which provides clarity. Keep going
Thank you for the kind words sir!
🙏 You are the Best Teacher that I have ever seen.🥇, A classical method of approach = Superb indeed.👌.🎯Please Could you kindly teach us Flutter & Dart & Go lang & Scala too . Pleeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeese Sir..... 🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏
This video is pure GOLD!!!
Honestly exceptionally well explained Sir, hats off
I am really amazed sir by your knowledge. Can you please share how you plan and learn all these things/concepts? Do you require them all these in your office related work regularly? I have been in IT industry for around 4-5 years but literally never faced these things, therefore never felt the need either to learn these. Please share some suggestions as senior developers to juniors on learning paths.
Exactly my feelings after been in the industry for a couple of decades. Learning from experience when applying concepts to real life work enhances understanding of concepts to the next level, something that prevail for years. I would be interested to know from Deepak, how he went about approaching concepts.
2:10 each core has its own cache and then there are shared caches. Thread running on core changes the variable in its local cache only, volatile keyword makes sure variable is flushed to shared cache when thread changes it so that changes are visible to all the other threads
6:05 happens before relationship
9:30 volatile keyword example
Hi can you help me
I am confused when i was trying real time as per the diagram in the time 00:03:52
here i used this...
System.out.println("the writerThread x is: "+x);
System.out.println("the readerThread r2 is:"+r2);
---------------------------------------------------------------------------------------------------------------------------------
like in this program(below):
public class FieldVisibility
{
int x = 0;
public void writerThread()
{
x = 1;
System.out.println("the writerThread x is: "+x);
}
public void readerThread()
{
int r2 = x;
System.out.println("the readerThread r2 is:"+x);
}
}
output is:--
the writerThread x is: 1
the readerThread r2 is:1
.......................................................................................
instead of
the writerThread x is: 1
the readerThread r2 is:0
Very nicely explained. Please keep making such videos.👍👍
You are my interview trainer...love you bro:)
Best explanation I've seen, great work!
Bro You are simply amazing. You may be not realised how much you are helping us. Thank You bhai :D
Awesome clarity. Voice is very clear and videos are well designed. Subscribed 👍
You are a fantastic teacher.. please please make more videos
Videos are very useful. Crisp & Clear. I request to make more videos
Crystal clear explanation!!! thanks a million .. I observed that the code was working fine though i had not used the volatile keyword at 9:37. what could it be the reason ?
It will work 99% of the time, but java memory model doesn't guarantee it will work all the time, thus we need the keyword
Thanks a lot for your your response.
Hi,
I have one request if you could make a video on Performance improvement techniques. Not necessarily related to threading but in general.
I am sure everyone would be benefited as you explain complex things in very simple way :)
Sure, sounds like a good idea. Will add it to the list
Very concise and easy to grasp. Great job!
What an excellent presentation, thank you for sharing
Best explanation of volatile so far... 👌
At 7:01 in video, x is volatile. But not a b or c. Will they also pushed back to main memory along with x? later in the same video you showing synchronise / locks for all fields
Hi, Thanks for the video.
How is the volatile or synchronized or lock usage different from having the field in the constructor?
Can't the shared cache object be used by putting the field in the constructor method and calling it in different threads?
But in multithreaded environment u can not be sure about which thread will get chance though we can override thread schedules behavior by setting priority...so in this case we need synchronization?
My another questions is when thread executes the run method is it the only method thread executes then what about about synchronized blocks and synchronized methods...do we need to write those inside run method.... please clear my doubts..
Its difficult to ensure one thread is scheduled before another even in case of priority (eg: if CPU is multi-core, both low and high priority threads can be scheduled together). So its better to code using concurrency utilities (eg: Latches, Semaphores, volatiles etc.)
Yes, most of the code that we want to run in a separate thread (as opposed to main thread) needs to be in run or call methods of Runnable/Called. Though, in Java 8, CompletableFuture or other frameworks/libraries could take your code in Supplier/Function/or any form, and run it within runnable without us knowing about it.
@@DefogTech thanks for the reply
That was really good. Thanks for posting, excellent, clear and to the point presentation, good job!
Thank you
Very clear video, though I would like suggest you to fix the code examples of locks or at least to have a disclaimer by voice that no one should use locks by your examples and should read a documentation instead which says you have to use "try { .. } finally { lock.unlock(); }" construct.
Agreed. Will add a card to the video. Thanks!
Explanation is very good and sharp!
Thanks for sharing this concept. I had only some theoretical knowledge of this before I watch this imp video.
Dude!! You are awesome, a true lifesaver. You are the first that have made it simple, at least that I have come across
Thanks much buddy!
I cannot understand one thing, how can synchronized work without volotile correctly, Does not thread copy x only to it's memory anyway?
Late comer :)
Question: How at 9:03 locks will result in maintaining the variables a,b,c,x being atomic? The locks are for methods, which I understand as, no other there can enter in THAT method, but if some other methods are executed, then you may get the stale data.
Isn't it?
Who the hell dislikes such a great videos??
other video makers :)
Awesome mate. You are really doing great, very impressive
This is one ultimate video...subscribed !!
Amazing presentation. All the videos are really helpful. Great work.
Can Volatile keyword be used with HashMap in any where code snippet. If yes, how to do that?
Crystal clear explaination... Loved it
In my case there is concurrent hashmap obj that holds configurations read from different server.
Quartz scheduler will fetch configuration data for every 30 sec and update a new data (whole obj) to this concurrent hashmap..
In this case ,in my opinion voltaile should be used to always get the updated obj to the reader threads but some quality checking tools raising it as bug
So any suggestions during this scenario
Great video, very clear explanation and examples. Thank you
Very good and crisp way of explanation. Keep doing this good :) work
Thank you!
This video is excellent.
very very good explanation, it shows you have studied very hard , Hats off to you.
But I will be very happy if you provide good working example to show difference between with volatile and without volatile,
because when I try to find out difference using volatile and without volatile I do not notice anyone. your example in video do not demonstrate difference when I try it myself.
thanks
Correct, so without volatile JVM doesn't guarantee other threads will see updated value. But it depends on speed of your operations, JVM implementation etc. Thus like for most concurrency issues it will work on local, will work in production for few days but might fail suddenly after
Yes you are correct, when I run my program again and again so many times then at some time situation arises and my volatile variable and non volatile variable get different values.
I will be happy to share program to you.
thanks
@DefogTech At time 8:47 How we are saying that value of all 4 variable will get updated while reading in readerThread because You are saying that X is not volatile. ??
As per first video of Volatile ,In this it was said that volatile values gets updated in Cache and because of that we are able to get updated value in different thread.
Please help in this..
Updates to variables are visible to other threads by using any one of the options, volatile, synchronized or locks. Thus if you are using synchronized, even if variable is not volatile, updates will still be visibile to other threads.
how we can test compiler optimise our code.
Ex : a = 3;
b = 2;
a = a + 1
to
a = 3;
a = a + 1;
b = 2
i wrote this code, compiled and check class file. but when it decompile same instruction appeared.
so how we can prove that, compier optimise our code.
Very good and simple explanation
2:50 loved this diagram man.
Oh thanks man. I wish you were my lecturer 😀
very simple to understand
Hi, Could you please make a video on memory management in java or provide a useful link for it. Thanks!!
Explaination with L2 and L3 is so deep. How do you get so deep
Hi dude, Love your explanations. I have a doubt though. The visibility problem that you have mentioned in this video using the boolean flag- my question is from that area. Is the problem of visibility in the flag question a mere chance or is a must case. Like if I don't use volatile in the flag, is it like in every scenario my code will get into an infinite loop in thread 1, despite the update done by thread 2 on the flag; or is it like may happen in certain scenarios and may not happen in others?
Thanks for your clear explanations.
The latter.. it may or may not be visible
@@DefogTech thanks man.....great content....love ur explanations
love your simple examples. thank you
Great video! Would it be possible to showcase when this happens? I've tried to replicate the issue with creating 2 new threads, however they seem to read x perfectly fine.
Sure, so it is possible that JVM will show the updated value to the other thread even though it is not say volatile, but, it is not guaranteed. In certain cases it can choose to keep using cached value. With volatile and other JMM rules we can be 100% sure that read-after always works.
Can you share your code please. I can take a look
public class JavaMemoryModel {
static int x = 0;
public static void writerThread() {
x = 11;
System.out.println("In writer thread: " + Thread.currentThread().getName() + ": " + x);
}
public static void readerThread() {
int r2 = x;
System.out.println("In reader thread: " + Thread.currentThread().getName() + ": " + r2);
}
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(6);
executorService.execute(new Runner());
executorService.execute(() -> readerThread());
executorService.execute(() -> writerThread());
executorService.execute(new Runner());
executorService.execute(() -> readerThread());
executorService.execute(() -> writerThread());
executorService.shutdown();
}
static class Runner implements Runnable {
@Override
public void run() {
x = 29;
System.out.println("In Runner Class: " + Thread.currentThread().getName() + ": " + x);
}
}
}
Something like this. How would you replicate the error of the shared cache not being updated?
Check this code
gist.github.com/DeepakVadgama/fdd282d9b10794ed21867dc912bafffd
Try calling reader and writer methods, instead of reader2 and writer2.
One uses atomicInteger, other uses int.
In the output, int shows inconsistent results, while atomicInteger one prints in correct order.
Really good explanation with a good visual display of those
Super video! I applauded for ₹40.00 👏
Could you make a samples of reactive programming followed by your aka Java fiber videos. For eg, How to use RxJava for the below categories of apps,
1. Considering both frontend and backend
2. Considering there is no frontend and it's purely backend app.
Doing good job. Really great👍
Does volitate mean value of x will be changed on shared cache or change it in local and only after instantly flush to shared?
I dont know if changes are instantly flushed, or lazily flushed when different thread also asks for same variable.
Excellent explanation. Thank you
So if two threads are runing in one core, there is no need to use volatile keyword because they share same cache?
yes but very difficult to do it
Hi I tried this fuctionality as you explained , Even if i keep as regular boolean instead of adding volatile, still the execution stops at some point. It does not run forever. Below is the example. Can you please explain why.
package java8.labdaexp;
public class VoltatileVisibility {
boolean flag=true;
public void writerThread() {
System.out.println("Write operation");
flag =false;
}
public void readerThread() {
while (flag) {
System.out.println("Read operation");
}
}
}
It may or may not happen. We cannot control the flush if we don't use volatile keyword. But if we use volatile keyword, it's guaranteed that the update will be flushed.
in most cases even without volatile the value is updated, but as per the spec JVM can choose to not show updates to other threads for perf or similar reasons. Using volatile is a guarantee given by spec itself.
Defog Tech Thanks for the explaination !!!
@@preetomsahaarko8145 Got it. Thanks !!!
everything to the point.. love ur videos bro❤️
U earned a fan today - Subscribed !
You're just brilliant! 🙏🏽
Awesome. Expected more videsos 👌👌👌
Thank you sir!
Very nice explanation appreciate it, thanks.
Short and Sweet
Thanks for a proper explanation on happens-before 🙂
Thank you very much sir!! You are amazing ❤️
Really loved the explanation. Thank you
Hi can you help me
I am confused when i trying the output as per the diagram in the time 00:03:52
here i used this...
System.out.println("the writerThread x is: "+x);
System.out.println("the readerThread r2 is:"+r2);
---------------------------------------------------------------------------------------------------------------------------------
like in this program(below):
public class FieldVisibility
{
int x = 0;
public void writerThread()
{
x = 1;
System.out.println("the writerThread x is: "+x);
}
public void readerThread()
{
int r2 = x;
System.out.println("the readerThread r2 is:"+x);
}
}
output is:--
the writerThread x is: 1
the readerThread r2 is:1
.......................................................................................
instead of
the writerThread x is: 1
the readerThread r2 is:0
Jigger u r love...
Awesome video....
Amazing teaching skills... Thanks a lot
Volatile won't work here. You have to use Atomic integer.... You have explained it in another of your videos.
Volatile vs Atomic
Awesome explanation and examples!
read write barrier means what sir please explain if we use volatile what happens to those barriers
Thank u, waiting for more videos on java
Good explanation !! :) Very usefull
Thank you for nice explanation and make more videos.
I think that the example with "a,b,c,x" is wrong. The program order is not the code order thus d1, d2 and d3 can be zeroes even when "x" is synchronized.
As per the JVM specification, any variables written to before synchronization by one thread, will be visible (updated values) to other threads using same synchronization. Thus even if a,b,c are not used for synchronization itself, their updated values are still visible to the other thread
Awesome video... Can u also make video on design patterns ...?
Volatile and with out Volatile keyword example differences am not getting clearly. Can some one explain and post here
Best explanations! Keep it up.
You are doing Great! Dude