Accenture Java Interview Questions & Answers

This video contains Java, Springboot, Microservices, Kafka interview questions and answers.
Accenture 2nd Round Interview: • Accenture | Round 2 | ...
Brillio 1st Round Interview: • Brillio | Round 1 | Ja...
Brillio 3rd Round Interview: • Brillio | Round 3 | Ja...
CGI Interview: • CGI Java Interview Que...
IBM Interview: • IBM Java Interview Que...
Nagarro Interview: • Nagarro Java Interview...
Concentrix Interview: • Concentrix (PKGlobal) ...
Wipro 1st Round Interview: • Wipro Java Interview Q...
Wipro 2nd Round Interview: • Wipro | Round 2 | Java...
Facebook: / javatechlead
Instagram: / javatechlead
Twitter: / javatechlead
Mail: [e-mail]
#java #springboot #microservices #java8 #elasticsearch #kafka #spring #javaInterviewQuestions​ #JavaInterviewQuestionsandAnswers​​​​​​ #JavaInterview​​​ #CoreJavaInterviewQuestions​​​ #JavaInterviewQuestionsandAnswersForExperienced​​​

[@pratapjavasingh3239]

Linked list not used Single Link List internally they're using double linked list but in array list used resizable or growable array means when we create array list then u are entering the value but unfortunately ur value will be cross the default limit size eg for u are inserting the value 12 elements then internally array list create second array list and all those things happening in internally.

[@Proman.Offbeat.Traveller]

Nyc information thanks for sharing it with us 😊

[@pratapjavasingh3239]

Volatile keywords used in variable levels and volatile variable when we use then jvm will create separate local cache and visible to one thread to another threads

[@niwasshashi6136]

but volatile can be used only for boolean data types right. If I want one thread to see the updated value by another thread for other data types I need to use AtomicInteger, Atomic Double etc

[@jeckrazi7691]

@@niwasshashi6136
correct;
The synchronised, volatile and Atomic are ways to achieve synchronisation.
We restrict the shared resource to be accessed by only one three at a time; when two or more thread needs access to the shared resource, there could be of "data/memory inconsistencies" and thread interference as the threads communicate primarily by sharing the access to the resource for faster and efficient execution of programs & and inter-thread communication can be achieved via wait(), notify() and notifyAll() methods (for producer-consumer problem) present inside the Object class;
Coming to volatile,
The volatile keyword is a non-lock based and to be used "only" with the variable and using it with the method or a class (other than with field) is illegal; It guarantees that the value of the volatile variable is "always" read from the main memory instead of from localThread cache and always "visible" to other threads thus all the other threads can see the updated value for that variable after the write operation thus we can avoid the "data inconsistencies" that can arise in the multi-threaded environments where multiple threads are accessing a particular variable; The volatile also informs the compiler not to perform any kind of optimization and re-ordering since multiple threads are to access this variable;
This is faster than "synchronised" which is applicable to only methods or blocks; because in Synchronised methods, the threads will acquire the lock(monitor) on the objects and then relinquishes the lock upon the completion of its purpose (Mutual Exclusion) and the waiting time for the threads to access the resource gets increased; (downside)
The volatile and atomic ( java.util.concurrent.Atomic) are both applicable to variable and the read and the write operations are atomic;
when to choose volatile and atomic?
If the value of the variable does not depend on its previous value, volatile can be used and suitable for boolean variables;
If the value of the variable "does" depend on its previous value, Atomic can be used because it provides methods to increment, decrement, compare and swap Operations (getAndSet(), getAndUpdate(), getAndIncrement(), incrementAndUpdate() and updateAndGet(); The classes involved are AtomicInteger, AtomicLong, AtomicDouble and AtomicReference;
More Importantly, the Atomic is faster than synchronised and volatile;
Both are immune to the concurrency hazards like DeadLock because of the non-(b)locking nature.

[@Proman.Offbeat.Traveller]

@@jeckrazi7691 very good explanation thanks for sharing it with us 😊

[@nullpointer500]

Was he selected in this round? Plz reply

[@shakthia5033]

is this really real time interview?

[@ManishTiwari-or8zt]

need to brush up his skills