Two Threads Sharing the Same Object

Question

I am learning Java multithreading recently and I really hit the wall when I came to synchronizing data using the synchronized keyword. According to the explanation, synchronized will only work when 2 or more threads are accessing the same object. If there are accessing 2 different objects, they can run the synchronized method in parallel.
My question now is how to make sure for synchronized method to work, I am actually working with the same and only one object??
Imagine this:
Two person with the same account number are trying to access the very ONE account at the same time.
I suppose the logic will be:
Two different socket objects will be created. When it comes to the login or authentication class or method, how can I make sure in term of object that the login/authentication class or method will return them only ONE object (because they share the same account), so that they will be qualified for using the synchronized method further down the road?
Thanks in advance!

Answer 1

Actually your understanding is wrong. Consider:
public class MyClass {
  private int someInt;
  private float someFloat;
  private synchronized void someMethod(final int value) {
    if (value > 2000) someInt = 2000;
  private synchronized void someOtherMethod(final float value) {
    if (value > 2.0) someFloat = 1.999f;
}YOu might think that two different threads can enter this code, one can enter in someOtherMethod() while one is in someMethod(). That is wrong. The fact is that synchronization works by obtaining synchronization locks on a target object. In this case by putting it on the method declaration you are asking for the lock on the 'this' object. This means that only one of these methods may enter at a time. This code would be better written like so ...
public class MyClass {
  private int someInt;
  private float someFloat;
  private void someMethod(final int value) {�
    synchronized(someInt) {
      if (value > 2000) someInt = 2000;
  private void someOtherMethod(final float value) {
    synchronized(someFloat) {
      if (value > 2.0) someFloat = 1.999f;
}In this manner you are only locking on the pertinent objects to the method and not on 'this'. This means that both methods can be entered simultaneously by two different threads. However watch out for one little problem.
public class MyClass {
  private int someInt;
  private float someFloat;
  private void someMethod(final int value) {�
    synchronized(someInt) {
      if (value > 2000) {
        someInt = 2000;
        synchronized (someFloat) {
          someFloat = 0.0f;
  private void someOtherMethod(final float value) {
    synchronized(someFloat) {
      if (value > 2.0) {
        someFloat = 1.99999f;
        synchronized (someInt) {
          someInt = 0;
}In this case you can have a deadlock. If two threads enter one of these methods at the same time one would be waiting on the lock for someInt and the other on the lock for someFloat. Neither would proceed. The solution to the problem is simple. Acquire all locks in alphabetical order before you use the first.
public class MyClass {
  private int someInt;
  private float someFloat;
  private void someMethod(final int value) {�
    synchronized (someFloat) {
      synchronized(someInt) {
        if (value > 2000) {
          someInt = 2000;
          someFloat = 0.0f;
  private void someOtherMethod(final float value) {
    synchronized(someFloat) {
      if (value > 2.0) {
        someFloat = 1.99999f;
        synchronized (someInt) {
          someInt = 0;
}In this manner one thread will block waiting on someFloat and there can be no deadlock.