Is @Transactional enough to keep concurrency in a table?

I have a table that contains a "stock" of codes to be used, like licenses. The repository is called CodeRepository. That code can be used just once so I need to assign those codes, once per service i'm activating. The repository for the services that use those codes is called ServiceRepository. I wrote the following code:

@Transactional
public void assignFreeCodeToService(Service service) {
    Code code = CodeRepository.findFirstByStatus("free").orElseThrow(() -> new ApiException(ApiException.ErrorCode.NOT_FOUND, "No available Code was found"));
    // change code status
    code.setStatus("assigned");
    // assign the code to the service
    service.setCode(code.geId());
    // save the code new status
    codeRepository.save(code);
    // save the service with the new code
    serviceRepository.save(service);
}

So, when i'm activating a service, this will assign a "code" and save it. What I want to know, if this code is enough to keep concurrency if two or more services are being activated at the same time. Will this code to prevent to use the same code twice?

Answering the initial Q:

> What I want to know, if this code is enough to keep concurrency if two or more services are being activated at the same time. Will this code to prevent to use the same code twice?

No. The reasoning is following:

1. in case of read committed isolation level (which is the default for the most mature DB's) your code is facing with lost update phenomena: it acquires Codes which have status=free and updates status to acquired not taking into account the fact the code has been potentially changed between acquisition and update
2. in case of repeatable read isolation level (default for MySQL) or higher you code may throw dumb errors like could not serialize access due to concurrent update and you should be ready to somehow mitigate such errors.

Suggestion of @nathan-hughes to use row-level locks is a good starting point, however spring-data API does not provide enough control over locking behaviour to make the code more concurrent.

@Transactional is used to implement local affair. It will make operation database isolate.So if the environment is stand-alone， you can use it.