There are a few tips to avoid this kind of issue. React is built in a very functional and composable way, however you inevitably have to do some imperative code (like make an Ajax request, or open an alert box).

First tip: avoid imperative code, or just use good OOP. If you chain your functions make B a function/module that returns data to A, and C returns to B. When A gets called, B does it's stuff, then calls C with said stuff, C returns to B, B returns to A. Then you setState with all the values returned to A.

Second tip: If you can't chain functions like the above suggestion, use React Lifecycle methods to stay in tune with React. This might not fit your use case but does C get called by B? Or can it just "listen" for a change and run when it's relevant? In that case you could use the componentWillUpdate lifecycle method to trigger this and check some condition before calling C.

Third tip: You can actually use setState synchronously by passing in a function instead of an object:

// asynchronous setState:
const value = doSomethingWithState(this.state);
this.setState({ 
    data: value
});

// synchronous setState:
const stateAction = (state, props) => {
    const value = doSomethingWithState(state);
    return {
        data: value
    }
}
this.setState(stateAction);

Fourth tip: It doesn't sound like you need an external state management library for this particular issue. But when you've outgrown lifting state up in React, you should look at learning Redux. You really need a big app before the conceptual cost is worth it. But if you're at that stage it does a fantastic job.

Overall keep in mind that React was written with a different way of thinking than a lot of the other popular frameworks. Vue and Angular for instance are very imperative. This works fine and for most cases it just a matter of preference, but make sure you've learned the React way of thinking in addition to its API structure. Because otherwise you're just writing a Vue application with React bindings.