Choose between UnpooledByteBufAllocator and Pooled in netty when merge many ByteBufs

I use AsyncHttpClient library for files download.
For example, I need to download 500 files from one host, each size about 10 MB, and write these files to disk. For this example, I will provide the below code:

1. Declare AsyncHttpClient. I use ResponseBodyPartFactory.LAZY to avoid copying into java heap

   final AsyncHttpClient asyncHttpClient = Dsl.asyncHttpClient(Dsl.config()
                .setFollowRedirect(true)
                .setResponseBodyPartFactory(AsyncHttpClientConfig.ResponseBodyPartFactory.LAZY)
                .setUseOpenSsl(true)
                .setRequestTimeout(6000000)
                .setUseNativeTransport(true)
                .build());
   

2. Declare ExecutorService, which will be used to write files. Use fixed size because default executor service can create 1000+ threads (he use cachedThreadPool)

    final ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2)
   

3. Code for files download. I used localhost because I want to get the maximum download speed and then write those files back to disk. The main part is in the method onBodyPartReceived

    for (int i = 0; i < downloadCount; i++) {
    asyncHttpClient.prepareGet("http://localhost/Pizigani_1367_Chart_10MB.jpg").execute(new AsyncHandler<Void>() {
        private long currentFilePosition;
        private AsynchronousFileChannel fileChannel;
        private CompositeByteBuf compositeByteBuf;
   
   
        @Override
        public AsyncHandler.State onStatusReceived(HttpResponseStatus status) throws IOException {
            if (status.getStatusCode() != 200) {
                return State.ABORT;
            }
            this.fileChannel = AsynchronousFileChannel.open(Paths.get("/tmp/" + UUID.randomUUID().toString() + "file.jpg"), EnumSet.of(StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE), executorService);
            this.compositeByteBuf = Unpooled.compositeBuffer(16);
            return State.CONTINUE;
        }
   
        @Override
        public State onHeadersReceived(HttpHeaders headers) {
            return State.CONTINUE;
        }
   
        @Override
        public void onThrowable(Throwable t) {
        }
   
        @Override
        public Void onCompleted() {
            return null;
        }
   
        @Override
        public State onBodyPartReceived(HttpResponseBodyPart content) {
            final ByteBuf responseByteBuf = ((LazyResponseBodyPart) content).getBuf().retain();
            final CompositeByteBuf compositeByteBuf = this.compositeByteBuf.addComponent(true, responseByteBuf);
            if (compositeByteBuf.numComponents() == compositeByteBuf.maxNumComponents() || content.isLast()) {
                final ByteBuf mergedDirectBuffer = UnpooledByteBufAllocator.DEFAULT.directBuffer(compositeByteBuf.readableBytes()); //or Pooled?
                for (ByteBuffer b : compositeByteBuf.nioBuffers()) {
                    mergedDirectBuffer.writeBytes(b);
                }
                compositeByteBuf.release();
                ByteBuffer asyncBuffer = mergedDirectBuffer.nioBuffer().rewind();
   
                long currentFilePosition= this.currentFilePosition;
                this.currentFilePosition += mergedDirectBuffer.readableBytes();
                this.compositeByteBuf = Unpooled.compositeBuffer(16);
                fileChannel.write(asyncBuffer, currentFilePosition, mergedDirectBuffer, new CompletionHandler<>() {
                    @Override
                    public void completed(Integer result, ByteBuf attachment) {
                        attachment.release();
                        if (content.isLast()) {
                            try {
                                fileChannel.close();
                            } catch (IOException e) {
                                throw new UncheckedIOException(e);
                            }
                        }
                    }
   
                    @Override
                    public void failed(Throwable exc, ByteBuf attachment) {
                        attachment.release();
                        try {
                            fileChannel.close();
                        } catch (IOException e) {
                            throw new UncheckedIOException(e);
                        }
                    }
                });
   
            }
   
            return State.CONTINUE;
        }
    });
   

   }

I'll write down some points:

1. Retain netty byteBuf from response.

final ByteBuf responseByteBuf = ((LazyResponseBodyPart) content).getBuf().retain();

2. Add this buffer to composite byte buf, It was done so that there were not many write operations to the disk, so I save up 16 buffers and only then write them to disk at once.

final CompositeByteBuf compositeByteBuf = this.compositeByteBuf.addComponent(true, responseByteBuf);

3. When size of composite buf is 16 or content is last, i allocate new direct buffer, using netty PoolingByteBufAllocator, which size is sum of all 16 buffers and write bytes into this one. After i release netty 16 bufs and write my direct buffer to file, when file written, then release my direct buffer.

           if (compositeByteBuf.numComponents() == compositeByteBuf.maxNumComponents() || content.isLast()) {
               final ByteBuf mergedDirectBuffer = UnpooledByteBufAllocator.DEFAULT.directBuffer(compositeByteBuf.readableBytes()); //or Pooled?
               for (ByteBuffer b : compositeByteBuf.nioBuffers()) {
                   mergedDirectBuffer.writeBytes(b);
               }
               compositeByteBuf.release();
               ByteBuffer asyncBuffer = mergedDirectBuffer.nioBuffer().rewind();
   
               long currentFilePosition= this.currentFilePosition;
               this.currentFilePosition += mergedDirectBuffer.readableBytes();
               this.compositeByteBuf = Unpooled.compositeBuffer(16);
               fileChannel.write(asyncBuffer, currentFilePosition, mergedDirectBuffer, new CompletionHandler<>() {
   

So question.
Should i prefer Pooled or Unpooled when merging buffers into a new direct buffer? It's just that some of my measurements show that Unpooled is faster, and Pooled often does not free memory.

And is the approach with writing the combined buffer to disk correct? maybe there are better ways?
I don't know netty very well.