@Propagation property of transactional requires_ New in-depth understanding

Premise

spring boot project ;sql server;druid Connection pool ;

Conclusion

requires_new Propagation properties , A new transaction will be created （ New connection ）, Hanging up old business means , In fact, it is because of the use of ThreadLocal To preserve DB Link information , Need to put ThreadLocal Only when it is processed into the information of the current transaction .

So two transactions There is also a competitive relationship of resources , Here is an example , Outer Affairs A REQUIRED, A new record will be inserted into test_a; Internal affairs B Will inquire about test_a All records , because sql server Default read committed Isolation level , So we need to wait until A After submission , To find out , But the business A Has been suspended , need B You can continue to run after execution .
That is, there is such a situation , Business A need B You can continue to run after execution , And the business B Waiting for business A Submit to continue , So it's locked ！！！

If we put things B, namely BService Methods isolation = Isolation.READ_UNCOMMITTED Set the isolation level lower , There will be no deadlock ！

Code examples studied

Make a use case first , stay springboot Inside the project

@RestController
@RequestMapping(value = "/test/transational/requiresnew", produces = "application/json;charset=UTF-8")
public class TransactionalRequiresNewController {
    @Autowired
    private AService aService;

    /**
     *  Outer layer required, Inner layer requires_new
     *  Insert new record in outer layer key1;
     *  Execute the inner layer ,selectAll, Insert new record key2;
     *  Insert a new record twice in the outer layer key3, Trigger error rollback ;
     *
     *  expect ：
     * 1. Will fall into a dead cycle , Because the insertion of the outer layer was not submitted ; Inner layer selectAll Been waiting ;
     * @return
     */
    @GetMapping("/deadLock")
    public String requiresNewDeadLock() {
        try {
            String s = aService.requiresNewDeadLock();
            System.out.println("requiresNewDeadLock: " + s);
            return s;
        } catch (Exception e) {
            e.printStackTrace();
            return "error";
        }
    }
}

// AService
    @Autowired
    private BService bService;
@Transactional(propagation = Propagation.REQUIRED)
    @Override
    public String requiresNewDeadLock() {
        keywordDao.insertToA("requiresNewDeadLock1");
        return bService.requiresNewDeadLock();
    }

// BService
@Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public String requiresNewDeadLock() {
       //  Will deadlock here . Previous transaction A Insert new data , But did not submit ,sql server Read submitted by default , So here requires_new New transaction B Been waiting ;
        List<String> strings = keywordDao.selectAllKeywordInA();
        return "ok";
    }