How to implement @Async in spring boot correctly in term of thread safety?

In spring boot when the web send a http request to a rest controller, the rest controller then may forward the request through the layer/s of the application (service, repository).
This process is guaranteed to be thread safe by spring.

As I'm quite new to multithreading, I came with the following question.

I have a specific request where the service layer is required to execute some calculation per a request. in order to not holding the user, I created a task service with method annoated with @Async.

@Service
public class MyService {
			
	@Autowired
	private MyTask myTask;
			
	@Async("taskExecutor")	
	public void launchCalc(Integer myId) {		
		...				
		myTask.execute(myId);			
	}		
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public synchronized void execute(Integer myId) {				                                  
	...
	someCalc(myId);				               
	...
}

I'm able to see in the log entries like: TaskExecutor-6 TaskExecutor-8 etc which means spring allocating threads from the pool each time.

What I'm getting is errors such as the following:

    [ TaskExecutor-2][36mo.h.engine.jdbc.spi.SqlExceptionHelper SQL Error: 1213, SQLState: 40001
 [TaskExecutor-2][36mo.h.engine.jdbc.spi.SqlExceptionHelper Deadlock found when trying to get lock; try restarting transaction

org.springframework.dao.CannotAcquireLockException: could not execute statement; SQL [n/a]; nested exception is org.hibernate.exception.LockAcquisitionException: could not execute statement

So, I realized that multiple thread compete on resources so what I did is marking the main method
with syncronized.
All problems disappeared but now user will have to wait (not really wait becuase I forward to different page but he won't be able to see the results of the calc) not only to finished his data calculation but also others which cause a usabilty problem.

The benfit of using @Async is minimal in this case, is there a way to do it better?

After spending hours on running again and again, I was able to isolate some
methods and found the following.

@Transactional(propagation = Propagation.REQUIRES_NEW)
public synchronized void execute(Integer myId) {                                                  
    ...
    someCalc(myId);                            
    ...
}

The method execute is the only method which has the annotation @Transactional.
someCalc(myId) is calling other methods within the same class which means by definition the same transaction applied or being used by those methods.

Now, one of the first method is doing repository.findById and save the entity to a member of the class. This was the main problem I think.

When debugging I saw that the entityId does not matches the entityId
in the children. So it looks like two threads come to a method and use different states.

In order to solve these errors what I did is calling repository.findById on the called methods (in each one of them) and load lazily the children when applicable.
The main method transfer the entityId only.

While I'm posting this as a solution I must say that I am not confident as two
threads can come to the same method one will load the entity by id and the other might use this entity.

The test is done by a loop of only 20.