Synchronized method access from other objects JAVA

Question

I have a method:

private synchronized Long generateID (Short company) throws Exception {
    IDDAO iDDAO = SpringApplicationContext.getBean (IDDAO.class);
    ID iD = iDDAO.findByNaturalKey (new IDNatKey (company);

    if (iD != null) {
        // Check if ID has reached limit, then reset the ID to the first ID
        if (iD.getLatestIDno ().longValue () == iD.getLastIDno ().longValue ()) {
            iD.setLatestIDno (iD.getFrstIDno ());
        }

        // Get next ID
        iD.setLatestIDno (iD.getLatestIDno () + 1);
        // update database with latest id
        iDDAO.update (iD);

        return iD.getLatestIDno ();
    }
}

In this code, I am updating the value of ID iD.setLatestIDno(iD.getLatestIDno() + 1). This is done in synchronized manner so that it never duplicates when accessed from multiple threads.

My question is if making this method synchronized will prevent other threads from accessing it? Or will other threads can access it from different objects? So shall it be made static?

The code is used like this

Long check = generateID (123);

Thanks

Answer 1

Other threads can accessed it from an other instance:

public synchronized Long generateID(Short company) {
    // do something
}

Is equivalent to:

public Long generateID(Short company) {
    synchronized(this) {
        // do something
    }
}

So if this refers to a different instance, the thread will not block.

If you want to synchronize threads over different instances, you need to provide a common lock:

Object lock = new Object();
MyClass c1 = new MyClass(lock);
MyClass c2 = new MyClass(lock);
// ...

// in MyClass:
private Long generateID(Short company) {
    synchronized(lock) {
        // do something
    }
}

You can also a use Lock instead of using synchronized on an object. The logic remains similar though.

Since you are using SpringApplicationContext, you can create a ReentrantLock and add it to your context and then access it the same you are accessing the IDDAO instance.

Answer 2

or some other threads can access it, from different objects ?

Of course they can, synchronized is only for syncing threads on specific object. I also wouldn't make it static - the easiest way to achieve what you want to do is using incrementAndGet() method from AtomicInteger (javadoc) class.

Definition:

public static AtomicInteger counter = new AtomicInteger(0); 
// starting number is 0, but can be changed

Usage:

int id = counter.incrementAndGet(); // assigns number 1
int otherId = counter.incrementAndGet(); // assigns 2

You can find a lot of examples when you google them, f.e. this one. There are many other methods AtomicInteger offers, I suggest you to look at the javadoc (see second link).

Thruth to be told, I didn't get why are you reseting IDs - but okay, let's say you need to do that. When ID gets through limit (let's say constant MAXIMUM_ID), there are many options how to do that:

• use modulo: counter.incrementAndGet() % MAXIMUM_ID, but overflow can happen so you need to take care of that;

• naive solution could be to just reset the counter:

  id = counter.incrementAndGet(); // too high
  if(id > MAXIMUM_ID) {
     counter = new AtomicInteger(0);
     id = counter.incrementAndGet(); // gets 1
  }   
  

Which prevents overflow. But then concurrency problem can happen - imagine two new counters are created, so both of them gets number 1. Therefore, instead of creating new AtomicInteger you just reset the value by method set(int value) (see javadoc for more info):

counter.set(0);

This approach is usually used because it should be faster and you are sure it is thread safe (also, why do something what is already done).

Answer 3

When 2 threads are about to execute a synchronized method in a class, they only conflict if they are working over the same instance of the object. In this case, only one thread at a time will be able to execute the method. The other thread will need to wait until the first one finishes its method call.

Notice that a thread holds its locks even when it goes to sleep, so you should synchronize as few lines of code as you can.

This could be achieved by synchronizing block of code (or even a single line of code) instead of whole methods.

class MyClass{
    public void myMethod(){
        ...
        synchronized(this){
            // All code in this block is synchronized.
        }
        ....
    }
}

If you must synchronize the operation over different instances, then you should make the method static. Once done this, you can synchronize the whole method:

class MyClass{
    public static synchronized void myMethod(){
        ...            
    }
}

or a block of code inside the method:

class MyClass{
    public static void myMethod(){
        ...
        Class c1 = Class.forName("MyClass");
        synchronized(c1){
            // All code in this block is synchronized.
        }
        ....
    }
}