《UNIX 高级环境编程（第三版）》笔记

The fork() function shall create a new process. The new process (child process) shall be an exact copy of the calling process (parent process) except as detailed below:

fork（）函数将创建一个新进程。新进程（子进程）应该是调用进程（父进程）的精确副本，但以下说明除外：

• The child process shall have a unique process ID.

  子进程应具有唯一的进程 ID。

• The child process ID also shall not match any active process group ID.

  子进程 ID 也不能与任何活动进程组 ID 相匹配。

• The child process shall have a different parent process ID, which shall be the process ID of the calling process.

  子进程应该有一个不同的父进程 ID，它应该是调用进程的进程 ID。

• The child process shall have its own copy of the parent's file descriptors. Each of the child's file descriptors shall refer to the same open file description with the corresponding file descriptor of the parent.

  子进程应拥有自己父文件描述符的副本。每个子进程的文件描述符都应指向与父对应文件描述符相同的打开文件描述。

• The child process shall have its own copy of the parent's open directory streams. Each open directory stream in the child process may share directory stream positioning with the corresponding directory stream of the parent.

  子进程应拥有自己父开放目录流的副本。子进程中的每个打开的目录流可以与父对应的目录流共享目录流定位。

• The child process shall have its own copy of the parent's message catalog descriptors.

  子进程应拥有自己父进程的消息目录描述符的副本。

• The child process' values of tms_utime, tms_stime, tms_cutime, and tms_cstime shall be set to 0.

  子进程的 tms_utime，tms_stime，tms_cutime 和 tms_cstime 的值应设置为 0。

• The time left until an alarm clock signal shall be reset to zero, and the alarm, if any, shall be canceled; see alarm().

  alarm clock 信号应剩余时间重置为零，并且如果有 alarm 的话，应取消。

• All semadj values shall be cleared.

  所有 semadj 值都应清除。

• File locks set by the parent process shall not be inherited by the child process.

  父进程设置的文件锁不应由子进程继承。

• The set of signals pending for the child process shall be initialized to the empty set.

  子进程挂起的信号集初始化为空集。

• Interval timers shall be reset in the child process.

  间隔计时器应在子进程中重置。

• Any semaphores that are open in the parent process shall also be open in the child process.

  任何在父进程中打开的信号量也应该在子进程中打开。

• The child process shall not inherit any address space memory locks established by the parent process via calls to mlockall() or mlock().

  子进程不应继承由父进程通过调用 mlockall（）或 mlock（）建立的任何地址空间内存锁。

• Memory mappings created in the parent shall be retained in the child process. MAP_PRIVATE mappings inherited from the parent shall also be MAP_PRIVATE mappings in the child, and any modifications to the data in these mappings made by the parent prior to calling fork() shall be visible to the child. Any modifications to the data in MAP_PRIVATE mappings made by the parent after fork() returns shall be visible only to the parent. Modifications to the data in MAP_PRIVATE mappings made by the child shall be visible only to the child.

在父进程中创建的内存映射应保留在子进程中。从父级继承的 MAP_PRIVATE 映射也应该是子进程中的 MAP_PRIVATE 映射，父进程中在调用 fork（）之前对这些映射中的数据所做的任何修改都应该对子级可见。在 fork（）返回后由父级所做的对 MAP_PRIVATE 映射中的数据的任何修改应仅对父级可见。子进程对 MAP_PRIVATE 映射中做的数据修改只能由子进程看到。

• For the SCHED_FIFO and SCHED_RR scheduling policies, the child process shall inherit the policy and priority settings of the parent process during a fork() function. For other scheduling policies, the policy and priority settings on fork() are implementation-defined.

  对于 SCHED_FIFO 和 SCHED_RR 调度策略，子进程应在 fork（）函数期间继承父进程的策略和优先级设置。对于其他调度策略，fork（）上的策略和优先级设置是实现定义的。

• Per-process timers created by the parent shall not be inherited by the child process.

  父进程创建的进程定时器不应该被子进程继承。

• The child process shall have its own copy of the message queue descriptors of the parent. Each of the message descriptors of the child shall refer to the same open message queue description as the corresponding message descriptor of the parent.

  子进程应拥有自己的父进程的消息队列描述符的副本。每个子进程的消息描述符应该指向与父对应消息描述符相同的开放消息队列描述。

• No asynchronous input or asynchronous output operations shall be inherited by the child process.

  子进程不应继承异步输入或异步输出操作。

• A process shall be created with a single thread. If a multi-threaded process calls fork(), the new process shall contain a replica of the calling thread and its entire address space, possibly including the states of mutexes and other resources. Consequently, to avoid errors, the child process may only execute async-signal-safe operations until such time as one of the exec functions is called. Fork handlers may be established by means of the pthread_atfork() function in order to maintain application invariants across fork() calls. 父进程应该是单线程。如果多线程进程调用 fork（），则新进程应包含调用线程的副本及其整个地址空间，可能包括互斥锁和其他资源的状态。因此，为避免错误，子进程可能只会执行异步信号安全操作，直到调用其中一个 exec 函数为止。可以通过 pthread_atfork（）函数建立 fork 处理程序，以便跨 fork（）调用维护应用程序不变量。

  When the application calls fork() from a signal handler and any of the fork handlers registered by pthread_atfork() calls a function that is not asynch-signal-safe, the behavior is undefined.

  当应用程序从信号处理程序调用 fork（）并且由 pthread_atfork（）注册的任何 fork 处理程序调用不是异步信号安全的函数时，行为是未定义的。

• If the Trace option and the Trace Inherit option are both supported:

  如果跟踪选项和跟踪继承选项都支持：

  • If the calling process was being traced in a trace stream that had its inheritance policy set to POSIX_TRACE_INHERITED, the child process shall be traced into that trace stream, and the child process shall inherit the parent's mapping of trace event names to trace event type identifiers. If the trace stream in which the calling process was being traced had its inheritance policy set to POSIX_TRACE_CLOSE_FOR_CHILD, the child process shall not be traced into that trace stream. The inheritance policy is set by a call to the posix_trace_attr_setinherited() function.

    如果调用进程在其继承策略设置为 POSIX_TRACE_INHERITED 的跟踪流中进行跟踪，则应将子进程跟踪到该跟踪流中，并且子进程应继承父进程的跟踪事件名称映射以跟踪事件类型标识符。如果跟踪调用进程的跟踪流将其继承策略设置为 POSIX_TRACE_CLOSE_FOR_CHILD，则不应将子进程跟踪到该跟踪流中。继承策略通过调用 posix_trace_attr_setinherited（）函数来设置。

• If the Trace option is supported, but the Trace Inherit option is not supported:

  如果支持 Trace 选项，但不支持 Trace Inherit 选项：

  • The child process shall not be traced into any of the trace streams of its parent process.

    子进程不应追溯到其父进程的任何跟踪流中。

• If the Trace option is supported, the child process of a trace controller process shall not control the trace streams controlled by its parent process.

  如果支持跟踪选项，则跟踪控制器进程的子进程不应控制由其父进程控制的跟踪流。

• The initial value of the CPU-time clock of the child process shall be set to zero.

  子进程的 CPU 时间时钟的初始值应设置为零。

• The initial value of the CPU-time clock of the single thread of the child process shall be set to zero.

  子进程的单线程的 CPU 时钟的初始值应设置为零。

All other process characteristics defined by IEEE Std 1003.1-2001 shall be the same in the parent and child processes. The inheritance of process characteristics not defined by IEEE Std 1003.1-2001 is unspecified by IEEE Std 1003.1-2001.

所有其他由 IEEE Std 1003.1-2001 定义的过程特性在父进程和子进程中应该是相同的。IEEE Std 1003.1-2001 未定义的过程特性的继承是不可靠的

After fork(), both the parent and the child processes shall be capable of executing independently before either one terminates.

在 fork()之后，父进程和子进程在任何一个终止之前都应该能够独立执行。

一个和 fork 相关的面试题

All process attributes are preserved during an execve(), except the following:

执行 execve() 期间会保留所有进程属性，但以下内容除外：

• The dispositions of any signals that are being caught are reset to the default (signal(7)).

  捕捉到的任何信号都重置为默认值。

• Any alternate signal stack is not preserved (sigaltstack(2)).

  不保留任何备用的信号堆栈。

• Memory mappings are not preserved (mmap(2)).

  不保留内存映射。

• Attached System V shared memory segments are detached (shmat(2)).

  附加的 System V 内存会分离。

• POSIX shared memory regions are unmapped (shm_open(3)).

  POSIX 共享内存区域会 unmapped。

• Open POSIX message queue descriptors are closed (mq_overview(7)).

  打开的 POSIX 消息队列会关闭。

• Any open POSIX named semaphores are closed (sem_overview(7)).

  任何打开的 POSIX 命名信号都是关闭的。

• POSIX timers are not preserved (timer_create(2)).

  不保留 POSIX 计时器。

• Any open directory streams are closed (opendir(3)).

  任何打开的目录流都会关闭。

• Memory locks are not preserved (mlock(2), mlockall(2)).

  不保留内存锁。

• Exit handlers are not preserved (atexit(3), on_exit(3)).

  不保留退出处理程序。

• The floating-point environment is reset to the default (see fenv(3)).

  浮点环境重置为默认值。

The process attributes in the preceding list are all specified in POSIX.1-2001. The following Linux-specific process attributes are also not preserved during an execve():

前面列表中的进程属性都在 POSIX.1-2001 中指定。在 execve()期间，也不会保留以下特定于 Linux 的进程属性：

• The prctl(2) PR_SET_DUMPABLE flag is set, unless a set-user-ID or set-group ID program is being executed, in which case it is cleared.

  除非正在执行 set-user-ID 或 set-group ID 程序，否则将设置 prctl（2）PR_SET_DUMPABLE 标志，在这种情况下它将被清除。

• The prctl(2) PR_SET_KEEPCAPS flag is cleared.

  prctl（2）PR_SET_KEEPCAPS 标志被清除。

• (Since Linux 2.4.36 / 2.6.23) If a set-user-ID or set-group-ID program is being executed, then the parent death signal set by prctl(2) PR_SET_PDEATHSIG flag is cleared.

  （自 Linux 2.4.36 / 2.6.23 起）如果正在执行 set-user-ID 或 set-group-ID 程序，则清除由 prctl（2）PR_SET_PDEATHSIG 标志设置的父死亡信号。

• The process name, as set by prctl(2) PR_SET_NAME (and displayed by ps -o comm), is reset to the name of the new executable file.

  由 prctl（2）PR_SET_NAME（并由 ps -o comm 显示）设置的进程名称将重置为新可执行文件的名称。

• The SECBIT_KEEP_CAPS securebits flag is cleared. See capabilities(7).

  SECBIT_KEEP_CAPS securebits 标志被清除。

• The termination signal is reset to SIGCHLD (see clone(2)).

  终止信号被重置为 SIGCHLD（参见 clone（2））。

Note the following further points: 请注意以下几点：

• All threads other than the calling thread are destroyed during an execve(). Mutexes, condition variables, and other pthreads objects are not preserved.

  在 execve（）期间，除调用线程之外的所有线程都将被销毁。互斥体，条件变量和其他 pthreads 对象不会被保留。

• The equivalent of setlocale(LC_ALL, "C") is executed at program start-up.

  setlocale（LC_ALL，“C”）的等价物在程序启动时执行。

• POSIX.1-2001 specifies that the dispositions of any signals that are ignored or set to the default are left unchanged. POSIX.1-2001 specifies one exception: if SIGCHLD is being ignored, then an implementation may leave the disposition unchanged or reset it to the default; Linux does the former.

  POSIX.1-2001 规定，任何被忽略或设置为默认值的信号的配置都保持不变。POSIX.1-2001 规定了一个例外：如果 SIGCHLD 被忽略，那么实现可能会保持处置不变或将其重置为默认值; Linux 做前者。

• Any outstanding asynchronous I/O operations are canceled (aio_read(3), aio_write(3)).

  任何未完成的异步 I / O 操作都会被取消（aio_read（3），aio_write（3））。

• For the handling of capabilities during execve(), see capabilities(7).

  有关在 execve（）期间处理功能的信息，请参阅功能（7）。

• By default, file descriptors remain open across an execve(). File descriptors that are marked close-on-exec are closed; see the description of FD_CLOEXEC in fcntl(2). (If a file descriptor is closed, this will cause the release of all record locks obtained on the underlying file by this process. See fcntl(2) for details.) POSIX.1-2001 says that if file descriptors 0, 1, and 2 would otherwise be closed after a successful execve(), and the process would gain privilege because the set-user_ID or set-group_ID permission bit was set on the executed file, then the system may open an unspecified file for each of these file descriptors. As a general principle, no portable program, whether privileged or not, can assume that these three file descriptors will remain closed across an execve().

  默认情况下，文件描述符在 execve()中保持打开状态。标记为 close-on-exec 的文件描述符将被关闭; 请参阅 fcntl（2）中的 FD_CLOEXEC 说明。 （如果文件描述符被关闭，这将导致此进程释放在底层文件上获得的所有记录锁。有关详细信息，请参阅 fcntl（2）。）POSIX.1-2001 表示如果文件描述符为 0,1 和 2，在成功的 execve（）之后将关闭 ，并且因为在执行的文件上设置了 set-user_ID 或 set-group_ID 权限位，该进程将获得权限，然后系统可以为这些文件描述符中打开未指定的文件。作为一般原则，不管是否有权限的可移植程序都可以假设这三个文件描述符将在 execve（）中保持关闭状态。

思考：一个线程对资源加锁了，另一个线程不加锁可以访问么？

当然可以，只有将所有线程都设计成遵守相同数据访问规则的，互斥机制才能正常工作。如果允许某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其他的线程在使用共享资源前都申请锁，也还是会出现数据不一致的问题。所以 要保证所有线程访问资源的规则是一致的 。

使用动态分配的互斥量，在释放内存前需要调用 pthread_mutex_destory。

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_destory(pthread_mutex_t *mutex);

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

int pthread_mutex_timelock(pthread_mutex_t *mutex, const struct timespec *tsptr);  // tsptr 是绝对时间

用互斥量解决前面的多线程竞争：参见 mutex.c

对已有互斥量再次加锁可能会导致死锁。

程序中使用多个互斥量，可以通过仔细控制互斥量加锁的顺序来避免死锁的发生。

可以用 pthread_mutex_trylock 接口避免死锁：如果该接口返回成功可以操作，否则，可以释放已经该占有的资源，做好清理工作，过一会再尝试。

有三种状态：加读锁，加写锁，不加锁。与互斥量相比，读写锁具有更高的并行性。非常适合于对数据结构读的次数大于写的情况。

虽然个操作系统对读写锁实现不同，但是当读写锁处于读模式锁住的状态，而这时有一个线程试图以写模式获取锁时，读写锁通常会阻塞随后读模式锁的请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。

int pthread_rwlock_init(pthread_rwlock_t *rwlock, pthread_rwlockattr_t *attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struce timespec *tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struce timespec *tsptr);

读写锁示例参见：rwlock.c

条件变量是线程可用的另一种 同步机制 （不是互斥机制）。条件变量与互斥量一起使用时，允许线程 以无竞争的方式等待特定的条件发生 。

条件本身是由互斥量保护的 。线程在 改变条件状态 之前必须首先锁住互斥量。其他线程在获得互斥量之前不会察觉这种改变，因为必须在锁定互斥量以后才能计算条件。

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
int pthread_cond_destroy(pthread_cond_t *cond);

int phtread_cond_wait(pthread_cond_t cond, pthread_mutex_t *mutex);
int phtread_cond_timedwait(pthread_cond_t cond, pthread_mutex_t *mutex, const struct timespec *tsptr);

传递给 pthread_cond_wait 的互斥量对条件进行保护。调用者把锁住的互斥量传给函数，函数然后自动把调用线程放到等待的线程列表上，对互斥量解锁。（这样就使得判断和休眠成了原子操作） 这就关闭了条件检查和线程进入休眠状态等待条件改变之间的时间通道，这样线程就不会错过条件的任何变化。

示例代码参见 cond.c

上面线程代码使用了 pthread_cond_wait(&cond,&mutex); 在条件变量上休眠等待主线程发送信号过来。 那么就存在一个问题：假想一下，当主线程发送信号过来后。在子线程 在 pthread_cond_wait 上等待发现信号发过来了，那么子线程将醒来并运行（注意这个时候 pthread_cond_wait 还未返回，那么锁是释放的，因为 pthread_cond_wait 在等待时会释放锁，返回时才会重新获得锁），那么如果这时候另一个线程改变了 i，但是切换到子线程时他并不知情，它会仍旧认为条件是满足的。也就是说我们不应该仅仅依靠 pthread_cond_wait 的返回就认为条件满足。 * pthread_cond_wait 返回时，线程需要重新计算条件，所以互斥量再次被锁住。*

等待信号端代码：

pthread_mutex_lock(&mutex); //必须先锁住条件，然后才能判断
while(condition is not match) { // 进行条件不满足判断，注意不要使用 if，从 wait 返回之后还需要进行条件判断
    pthread_cond_wait(&cond, &mutex);
 }
/* 在这里做一些修改条件的操作 */

pthread_mutex_unlock(&mutex);

产生信号端代码：

pthread_mutex_lock(&p_lock);
/* 这里是修改条件的代码，是条件成立 */
pthread_mutex_unlock(&p_lock);

pthread_cond_signal(&cond);

自旋锁与互斥量类似，但它不是通过休眠使线程阻塞，而是在获取锁之前一致处于忙等待阻塞状态。自旋锁主要用于以下情况：锁被持有的时间短，而且线程并不希望在重新调度上花费太多的成本。

自旋锁通过作为底层原语实现其他的类型的锁。

当自旋锁用在非抢占式内核中时是非常有用的：除了提供互斥机制以外，它们会阻塞中断，这样中断处理程序就不会让系统陷入死锁状态，因为它需要获取已被加锁的自旋锁。

但在用户层，自旋锁并不是非常有用，除非运行在不允许抢占的实时调度类中。运行在分时调度类中的用户层线程在两种情况下可以被取消调度：当它们的时间片到期时，或者具有更高调度优先级的线程就绪变成可运行时。在这些情况下，如果线程拥有自旋锁，它就会进入休眠状态，阻塞在锁上的其他线程自旋时间可能比预期的时间更长。

很多互斥量的实现非常高效，以至于应用程序采用互斥锁的性能与曾经采用过的自旋锁的性能基本是相同的。事实上，有些互斥量的实现在试图获取互斥量的时候会自旋一小段时间，只有在自旋计数到达某一阈值的时候才会休眠。这些因素，加上现代处理的进步，使得上下文切换变得原来越快，也似地自旋锁只有在特定的情况下有用。

int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);

int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);

注意：

1. 对已经加锁的自旋锁加锁结果是未定义的，调用 pthread_spin_lock 会返回 EDEADLK 错误（或其他错误），或者调用可能会永久自旋。具体行为依赖于实际的实现。
2. 试图对没有加锁的自旋锁解锁结果也是未定义的。
3. 不要调用在持有自旋锁的情况下可能会进入休眠状态的函数。如果调用了这些函数，会浪费 CPU 资源，因为其他线程需要自旋锁需要等待的时间就延长了。

屏障是用户协调多个进程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都到达某一点，然后从该点继续执行。

简单来说：

• cond 情景：条件达到了，大家一起干，干完大家就没事了（pthread_exit）。
• barrier 情景：先大家干到统一进度，然后在各自干各自的。

int pthread_barrier_init(pthread_barrier_t *barrier , const pthread_barrierattr_t *attr, unsigned int count);
int pthread_barrier_destory(pthread_barrier_t *barrier);
int pthread_barrier_wait(pthread_barrier_t *barrier);

示例代码参见barrier.c

只支持进程共享属性。

支持进程共享属性和时钟属性。

只支持进程共享属性。