多个方法之间的Java同步

Question

class xyz {

    private Object lock = new Object();

    // value will come from database
    private boolean deleteOncePerDay; 

    private void clearAll() {
        synchronized (lock) {
            if(!deleteOncePerDay) {
                database.deleteNames();
                database.deleteAddresses();
                database.deletePhoneNums();

                // set database value to true
                deleteOncePerDay = true;
            }
        }   
    }

    @Scheduled(fixedDelay = 50000)
    public void fetchNames() {
        clearAll();
        synchronized (lock) {
            database.saveNames();
        }
    }

    @Scheduled(fixedDelay = 50000)
    public void fetchAddresses() {
        clearAll();
        synchronized (lock) {
            database.saveAddresses();
        }
    }

    @Scheduled(fixedDelay = 50000)
    public void fetchPhoneNums() {
        clearAll();
        synchronized (lock) {
            database.savePhoneNums();
        }
    }

}

The 3 fetch methods work in different threads and each fetch method take different times to save their data.

My Objectives:

1. When one thread is deleting (ClearAll) data, no other thread should save data simultaneously.

2. When a thread is saving data, no other thread should be deleting data.

3. When no threads are working on clearAll(), All threads can save data simultaneously.

With the above i guess i achieved 1 & 2. But i missed 3. since each fetch method is enclosed by synchronized block, only fetch method will get lock at time, so doesn't satisfy condition 3.

Can someone help me?

Answer 1

In this case, you can use ReadWriteLock in java. Instead of synchronized(lock){} blocks, use that as follows.

// Initialization
ReadWriteLock lock=new ReentrantReadWriteLock();

In the clearAll() method.

lock.writeLock().lock();
try{
    // Do your stuff here
} finally{
    lock.writeLock().unlock();
}

In all the other methods, just get a read lock and do your stuff.

lock.readLock().lock();
try{
    // Do your stuff here
} finally{
    lock.readLock().unlock();
}

A ReadWriteLock allows any number of threads to get the read lock, but to get the write lock, all the read locks have to be released. Furthermore, no read can happen when a write lock is taken.

Also, I think you should look at database transactions where you can achieve all these at the database level .

Answer 2

@Scheduled(fixedDelay = 50000)
    public void whatever() {
        clearWhatever(); // no one passed barrier, no saves happening
        CyclicBarrier();
        database.saveWhatever(); // all passed barrier, no clears happening.

    }

this should divide work into clear and save without concurrency problems according to your 1,2,3 cases.