why not tasksSubmitted++ instead of 2-line dance

Indeed all access to this variable is guarded by lock so there is no need to mark in volatile

Also name is a bit confusing. One can interpret it as "amount of tasks submitted to THIS executor, not inner one".
I would suggest name like runningTasksCount (as those tasks are actually running while others are just sitting in the queue)

Also using synchronized will result in much more concise code:

public synchronized int getTasksSubmitted() {
    return tasksSubmitted;
}

Even though it is kinda old-fashioned and not really encouraged these days.
UPD:
Just to clarify what I mean: if we get rid of mainLock and just use synchronized everywhere then we end up with less code.

ACHTUNG SCHWIERIGEN BUGGEN!
Access to taskQueue should be guarded by same lock.
If linter doesn't complain about this one then I suggest to turn off this linter )

Overall this approach will ofc work (if implemented correctly).
Minor suggestion would be to move logic for incrementing tasksSubmitted and submitting tasks to one method "tryExecute" or something and than change logic of execute to put task in a queue anyway and then call "tryExecute". Same thing after each task is finished - just call "tryExecute"

Major suggestion would be to try to come up with non-blocking implementation (just using non-blocking queue) to reduce thread contention and maximize performance (parking thread while waiting for a lock is still bad if you use non-blocking IO and stuff)

I sketched possible non-blocking solution in Kotlin (haven't test it, it's just a raw idea):

import java.util.concurrent.ConcurrentLinkedDeque
import java.util.concurrent.Executor
import java.util.concurrent.atomic.AtomicInteger

class LimitedExecutor(private val baseExecutor: Executor, private val parallelTaskLimit: Int) : Executor {
    private val taskQueue = ConcurrentLinkedDeque<Runnable>()
    private val tasksRunning = AtomicInteger()

    override fun execute(command: Runnable) {
        taskQueue.add(command)
        trySubmit()
    }

    private fun trySubmit() {
        val running = tasksRunning.get()
        if (running < parallelTaskLimit) {
            val task = taskQueue.poll()
            val res = tasksRunning.compareAndSet(running, running + 1)
            if (res) {
                baseExecutor.execute(createTaskWrapper(task))
            } else {
                taskQueue.addFirst(task)
            }
        }
    }

    private fun createTaskWrapper(command: Runnable): Runnable = Runnable {
        try {
            command.run()
        } finally {
            tasksRunning.decrementAndGet()
            trySubmit()
        }
    }

    fun getTasksSubmitted(): Int = tasksRunning.get()
}

UPD:
Neh, it won't work :(. Need to think more.