tlpi | 对tlpi这本书的学习

The pipe function has this signature:

Here is a simplified example:

The problem is with your second gcc command, where you're using the -o file to specify the output file where to store the resulting executable file, but passing it the name of the C source file seek_io.c instead...

For the undefined references, someone asked a very similar answer here How to compile examples in the book "The Linux Programming Interface" by Michael Kerrisk

Then, if that does not work, I would suggest to try again by downloading the source file as specified at the TLPI web site and you can look into the makefile for your script, which is in the fileio/ subfolder and the Makefile.inc file.

I'm implementing a set of thread-safe functions that update and search an unbalanced binary tree with Pthreads (see The Linux Programming Interface: Exercise 30.2).

It's easy to implement a 'functional' tree that simply locks the entire body of functions like add or delete, but I believe it possible to implement an unbalanced binary (search) tree with a locking strategy that allows for almost all the work to be parallelized by minimizing time spent in a critical section.

Yes and no. If two or more threads are to access the same shared data, and at least one of them modifies it, then both threads' accesses must be protected by some form of synchronization. Since you cannot, in general, predict in advance which nodes may be modified, all accesses need to be synchronized. On the other hand, the scope of the protected region can vary dynamically. Tree search, addition, and deletion algorithms for an unbalanced tree can narrow the scope of needed synchronization as they go, as in principle they only need to protect a subtree. Another thread could reasonably operate at the same time on a separate subtree.

Before you get excited about that, however, be aware that changing the synchronization scope is going to require a mutex lock and unlock (or vise versa, depending on your approach), and these are not cheap. You might find, in fact, that all the mutex locking and unlocking eats up most or all of the gains from parallelizing operations.

However, if you anticipate that searches will be the predominant operation on your tree, with additions and deletions being comparatively rare, then you could consider implementing a read/write lock. The idea there is that you permit any number of threads to search the tree at the same time, but a thread that wants to modify it must be granted exclusive access to the whole tree before it can do so.