java - How to ensure an iterator with a read lock will unlock even if it doesn't finish? - Stack Overflow

admin管理员组

文章数量:1344569

I have a collection. Many threads should be able to read from it at a time, but only one thread should be able to write to it at a time, and only when it's not being read. Java's ReentrantReadWriteLock seems prefect for this.

However, I am confused about how to write the iterator for the collection. The iterator should obtain the read lock when it starts. But I can't figure out how to ensure that it will unlock in the case when the iterator never finished.

Here's some example code that is just a wrapper around a normal iterator that locks and unlocks:

import java.util.Iterator;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

public class ReadLockIterator<T> implements Iterator<T> {
    
    private final Lock lock;
    private final Iterator<T> iterator;
    
    public ReadLockIterator(ReadWriteLock lock, Iterator<T> iterator) {
        this.lock = lock.readLock();
        this.iterator = iterator;
        this.lock.lock();
    }
    
    @Override
    public boolean hasNext() {
        return iterator.hasNext();
    }

    @Override
    public T next() {
        try {
            return iterator.next();
        }
        finally {
            if(!hasNext())
                lock.unlock();
        }
    }
}

This will work fine as long as the user gets every element from the iterator. But what happens if the user doesn't do that? How can I ensure that the lock will eventually be released, even if some elements are never read from the iterator?

My first thought was to put a second check in the iterator's finalize() method, but then I read that finalize should not be used for unlocking.

What's the best way to handle this?

I have a collection. Many threads should be able to read from it at a time, but only one thread should be able to write to it at a time, and only when it's not being read. Java's ReentrantReadWriteLock seems prefect for this.

However, I am confused about how to write the iterator for the collection. The iterator should obtain the read lock when it starts. But I can't figure out how to ensure that it will unlock in the case when the iterator never finished.

Here's some example code that is just a wrapper around a normal iterator that locks and unlocks:

import java.util.Iterator;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

public class ReadLockIterator<T> implements Iterator<T> {
    
    private final Lock lock;
    private final Iterator<T> iterator;
    
    public ReadLockIterator(ReadWriteLock lock, Iterator<T> iterator) {
        this.lock = lock.readLock();
        this.iterator = iterator;
        this.lock.lock();
    }
    
    @Override
    public boolean hasNext() {
        return iterator.hasNext();
    }

    @Override
    public T next() {
        try {
            return iterator.next();
        }
        finally {
            if(!hasNext())
                lock.unlock();
        }
    }
}

This will work fine as long as the user gets every element from the iterator. But what happens if the user doesn't do that? How can I ensure that the lock will eventually be released, even if some elements are never read from the iterator?

My first thought was to put a second check in the iterator's finalize() method, but then I read that finalize should not be used for unlocking.

What's the best way to handle this?

• java
• multithreading
• concurrency

Share Improve this question Follow edited 13 hours ago Mark Tolonen 179k2626 gold badges180180 silver badges270270 bronze badges asked 14 hours ago Stephen WareStephen Ware 11122 silver badges77 bronze badges 0

Add a comment  | 

3 Answers 3

Sorted by: Reset to default 1

There is not a good way to handle this. The most viable strategy is to require every user of your iterator to wrap the usage in lock/unlock. If you find yourself saying, "That's not a very viable strategy," I would agree, but that doesn't mean that a better solution exists.

The case of the synchronized collections illustrates this, as every user of those collections has to manually lock the collection: it's very awkward, but there isn't a better way.

It may just be the case that there is no good solution to this problem, as Louis Wasserman has mentioned. I certainly can't come up with a good one.

I did want to post something, even if it's not a very good solution. This is an improved version of my iterator wrapper. It is guaranteed to unlock if the wrapped iterator reaches the end of the collection or if the wrapped iterator throws an exception. It also implements the AutoCloseable interface so that it clearly advertises that it uses a resource that needs to be released. This doesn't really solve the problem, but at least it reduces the chance that a user will misuse it.

import java.util.Iterator;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

public class ReadLockIterator<T> implements Iterator<T>, AutoCloseable {
    
    private final Lock lock;
    private final Iterator<T> iterator;
    private boolean hasNext;
    private T next;
    private boolean closed = false;
    
    public ReadLockIterator(ReadWriteLock lock, Iterator<T> iterator) {
        this.lock = lock.readLock();
        this.iterator = iterator;
        this.lock.lock();
        advance();
    }
    
    @Override
    public boolean hasNext() {
        return hasNext;
    }

    @Override
    public T next() {
        if(!hasNext)
            throw new NoSuchElementException("The iterator has no more elements.");
        T next = this.next;
        advance();
        return next;
    }

    @Override
    public void close() {
        if(!closed) {
            hasNext = false;
            closed = true;
            lock.unlock();
        }
    }
    
    private void advance() {
        hasNext = false;
        try {
            if(!closed && iterator.hasNext()) {     
                next = iterator.next();
                hasNext = true;
            }
        }
        finally {
            if(!hasNext)
                close();
        }
    }
}

You should make a lock class for your collection that implements AutoCloseable and Iterable.

Then you can use try-with-resources to make sure the lock is closed, and your iterator implementations can fail if the lock is not open:

try(MyLock lock = myCollection.getReadLock()) {
    for(Item item: lock) {
        ...
    }
}

本文标签： javaHow to ensure an iterator with a read lock will unlock even if it doesn39t finishStack Overflow