Wie vermeidet man die gleichzeitige Ausführung von zwei Methoden?

Question

Ich habe zwei synchronized Methoden, von denen jede von einem anderen Thread ausgeführt wird.

public synchronized ResultSet dbExecuteQuery(String queryStmt); 

public synchronized void dbExecuteUpdate(String queryStmt); 

Wie kann ich sicherstellen, dass ihre Ausführung nicht "überlappt"?

Eine Lösung, die mir in den Sinn kommt, ist die folgende:

public synchronized ResultSet dbExecute(String queryStmt, boolean isUpdate) { 
if (isUpdate) { 
    dbExecuteUpdate(queryStmt); 
    return null; 
} else 
    return dbExecuteQuery(queryStmt); 
} 

Aber es bedeutet, würde ich den ganzen Code in das gesamte Projekt verwendet ändern. Gibt es einen saubereren Weg, es zu tun?

Answer 1

Sie können eine dedizierte Synchronisationsobjekt hinzufügen:

class YourClass { 
    Object syncObject = new Object(); 
    public ResultSet dbExecuteQuery(String queryStmt) { 
     synchronized(syncObject) { 
      // your code 
     } 
    } 

    public void dbExecuteUpdate(String queryStmt) { 
     synchronized(syncObject) { 
      // other code 
     } 
    } 
} 

Aber es ist wahrscheinlich besser, eine ReentrantLock zu verwenden.

class YourClass { 
    private Lock lock = new ReentrantLock(); 
    public ResultSet dbExecuteQuery(String queryStmt) { 
     lock.lock(); 
     // your code 
     lock.unlock(); 
    } 

    public void dbExecuteUpdate(String queryStmt) { 
     lock.lock(); 
     // other code 
     lock.unlock(); 
    } 
} 

Eigentlich, da man ein Lese- und ein eine Schreib, werden Sie wahrscheinlich ReadWriteLock verwenden möchten.

class YourClass { 
    private ReadWriteLock lock = new ReentrantReadWriteLock(); 
    public ResultSet dbExecuteQuery(String queryStmt) { 
     lock.readLock().lock(); 
     // your code 
     lock.readLock()..unlock(); 
    } 

    public void dbExecuteUpdate(String queryStmt) { 
     lock.writeLock()..lock(); 
     // other code 
     lock.writeLock().unlock(); 
    } 
} 

Auf diese Weise können Sie gleichzeitig lesen mehrere Threads haben:

The read lock may be held simultaneously by multiple reader threads, so long as there are no writers. The write lock is exclusive.