Lazily decode a buffer with a thread-safe Iterator

I have implemented an Iterator for my Pojo class.
The purpose here is to lazily decode multiple Pojos encoded in a buffer (bytes array).
To improve performance, it needs to be thread-safe to be correctly used from multiple Thread (parallel Stream).
The buffer is formed as follows :

1. The first 4 bytes represent an int indicating how many bytes the next element uses in the buffer : n.
2. The following n bytes are encoded representation of a single Pojo.
3. 4 other bytes for the length of the next element.
4. And so on ...

I think it is achieved with this code :

public class StringDecodeIterator implements Iterator<Pojo> {

        private final int size;
        private final PojoDecoder decoder;
        private final byte[] buffer;
        private int offset = 0;
        private int count = 0;

        private StringDecodeIterator(int size, PojoDecoder decoder, byte[] buffer) {
            this.size = size;
            this.decoder = decoder;
            this.buffer = buffer;
        }

        @Override
        public synchronized boolean hasNext() {
            return this.count < this.size;
        }

        @Override
        public Pojo next() {
            return this.decoder.decode(offset(), this.buffer);
        }

        private synchronized int offset() {
            if (!(this.count < this.size)) {
                throw new NoSuchElementException("No more element");
            }
            this.count++;
            int o = this.offset;
            this.offset += Utils.getInt(o) + 4;
            return o;
        }

    }

Here are some explanations/details :

1. size is the number of element to decode : It is a known value; we know how many Pojos are encoded.

2. PojoDecoder decoder is an object that can decode Pojos from a buffer at a given position.

   interface PojoDecoder {
       Pojo decode(int offset, byte[] buffer);
   }
   

3. Utils#getInt(int); just converts 4 bytes to an int from the given position.

4. PojoDecoder#decode(int, byte[]) does not need to be in the thread-safety scope. Same instance can be used from multiple threads, as it does not hold any internal state.