A suspended stream is one that, as you say, is blocked on the socket being read, waiting for the semaphore to become available, etc.
Given that POSIX implementations differ in complex edges and that there is a possibility of blocking a thread in a function that is not a cancellation point, it may be that relying on canceling the code that needs to be ported has more problems than it costs.
I never used it, I always wanted the code to explicitly instruct the thread to stop (usually a message down the pipe or queue). This is very easy using serial communication processes or the Actor Model system.
Thus, cleaning can be done under its own control, freeing up memory, etc. as needed. I don’t know if the canceled thread will clear its memory (I suspect not), or there is an option for a type like at_exit () (maybe). In general, I think that the behavior of the application is more closely controlled if there is only one way to exit the stream.
== == EDIT
@JohnBollinger,
The language used If a thread has cancelability enabled and a cancellation request is made with the thread as a target while the thread is suspended at a cancellation point can be interpreted as IF a thread has cancelability enabled AND IF cancelled and IF implementation suspends blocked threads AND IF the thread is blocked THEN the thread shall be awakened... In other words, they leave it until the implementation of the POSIX subsystem.
The implementation of Cygwin select () does not (or at least not) causes the thread to pause. Instead, it generates a polling stream for a file descriptor to check signal-related activity due to the fundamental lack of anything like select () on Windows (it comes close, but not cigars. Win32 select () only works with sockets). The implementations of select () back in the 1980s also worked the same way.
Perhaps for such reasons, POSIX does not want to clearly determine when a thread is paused. Historically, many implementations of select () have been such as to make it a minefield for the standardization committee to tell when a thread may or may not be suspended. Of course, the difficulties caused by select () also apply to the process, but since POSIX really defines a paused process, it seems strange that they could not / did not extend the definition to threads.
Perhaps this is due to how the threads are implemented; you can probably have a POSIX implementation that does not use OS threads (a bit like the early ADA implementations in those days when the OS did not execute threads at all), and in such an implementation a blocked thread may not be suspended (in the sense of no processor cycles) .