Why the most dominant programming languages didn't follow CSP thread model?
There are many approaches for concurrency, with different tradeoffs.  We have threads with shared mutable state (e.g., SRC-style threading).  We have coroutines (like Go).  We have actor models with independent processes communicating via message passing (like Erlang or E).

I would put CSP on a different level.  It's not the same sort of thing.  The form of CSP that I am familiar with is a mathematical, theoretical formalism that can be used to model concurrent systems.  It's not really a model of programming that can be directly used in programming languages.  It's more like the lambda calculus.  You can build programming language APIs inspired by CSP, just like Lisp and Scheme are inspired by the lambda calculus, but it's not directly a design of a thread API itself.

Why did early languages choose to follow the SRC model rather than something inspired by CSP?  Well, all I can share with you is speculation.  The SRC model is a low-level model that maps pretty closely to the primitives provided by processors: it is a thin level of abstraction over that.  Just like C is a thin layer over assembly language (and doesn't use, say, functional or declarative paradigms), it's not surprising that early languages would provide a thin layer over processor primitives (rather than, say, other theoretical paradigms).  Also, the SRC model works well with existing code and existing programming languages.  You can take existing sequential code and then add threads.  When you're writing threaded code, the sequential part of the computation looks just like code written for a non-threaded language.  That backwards compatibility and familiarity was probably significant.  The SRC model could be deployed as a library, without requiring changes to programming language syntax or compilers.  I have to imagine that might have been a significant factor in its adoption.  Also, the SRC model is somewhat similar in many ways to existing Unix primitives for running code in parallel in multiple processes, which I imagine might also have been beneficial for adoption.  This is just my speculation.  Perhaps someone else will be able to provide a more researched answer.