Multithreading is certainly popular to pee on these days. It requires a fairly high level of understanding of how your data flows to get right, and languages do not help you out in that mechanism.
So CSP-based models have gained a lot of popularity, as a way to kludge around it and get most of the benefit (but shared memory is still a property of threading I don't see emergent in the CSP approaches currently).
To the extent that multithreading is popular to pee on, it's precisely because of the shared memory, or more accurately, the shared mutable variables. There's a lot of interesting concurrency solutions being developed, but it looks to me that shared mutable variables aren't going to be in any of them, so don't hold your breath waiting for them to come back. (The video at [1] is interesting overview of all the various Haskell solutions, which is interesting beyond just Haskell as an overview of a variety of concurrency approaches.)
Shared memory can give strong performance advantages that the alternatives don't have. You pay for this in implementation complexity. Each can decide how much he or she wants to pay.
The price could be lowered by some trivially better support functions. Why for example C++0x doesn't have lockless concurrent containers in the standard library is beyond me.
So CSP-based models have gained a lot of popularity, as a way to kludge around it and get most of the benefit (but shared memory is still a property of threading I don't see emergent in the CSP approaches currently).