想请问仿真实验的意义和目的是什么

线程同步的方式包括：互斥锁、读写锁、条件变量、信号量和令牌。以Java语言为例：用synchronized关键字修饰同步方法。同步有几种实现方法分别是synchronized,wait与notifywait():使一个线程处于等待状态，并且释放所持有的对象的lock。

条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待条件变量的条件成立而挂起；另一个线程使条件成立（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。条件变量类型为 pthread_cond_t。

两组实验中改变一组实验中的一个条件 其余条件不变例在做青蛙对光的影响的实验中改变一组青蛙中光的亮度 一组在正常光下 确保其他条件不变这是在实验中常用的方法 准确的说叫控制变量法。

先看一下APUE第三版对于条件变量的说明: 条件变量是另一种线程同步机制，它为线程间共享的对象提供了同步的方法。当条件变量配合互斥锁(Mutex)使用时,允许多个线程处在一种自由等待任意条件发生的状态。 条件变量自身由互斥锁(Mutex)保护。线程必须在修改条件状态之前先对其上锁，其他线程不会在获取锁之前被通知到其状态变化，因为只有获取到锁才可以计算条件。 条件变量的数据类型是 pthread_cond_t ，条件变量属性的类型是 pthread_condattr_t ，它们都包含在头文件<pthread.h>中。 条件变量使用之前必须初始化，有两种方法： 需要释放条件变量时，使用pthread_cond_destroy即可。 调用phread_cond_wait或pthread_cond_timewait(以下简称wait函数)可以使当前线程等待某一条件的发生。两者的区别在于后者可以指定等待时间。 调用wait函数时，系统使调用线程进入等待状态后 释放锁 (所以我们必须先加锁后调用wait函数)。在这一步操作中的检查条件和进入等待是 原子操作 ，所以线程不会错过条件的变化。当wait函数返回时，mutex会 再次被加锁 。 其中pthread_cond_timewait中用到的timespec结构定义如下: 需要注意的是,timespec是一个绝对时间，所以在使用前我们需要先取得当前时间，再加上等待时间。例如下面这样： 如果时间到了还没有等到条件变化，函数会对mutex重新加锁并返回一个ETIMEOUT的错误。 当wait函数返回成功时， 需要重新检查条件 ，因为条件有可能已经被其他线程修改。 当条件满足时，可以用这两个函数用来通知其他线程。 pthread_cond_signal会唤醒至少一个等待的线程，而pthread_cond_broadcast会唤醒所有等待的线程。必须注意的是：我们 必须在状态发生变化之后再发送信号给其他线程 。 条件变量的数据类型是 pthread_cond_t ，它主要有两种属性： 设置进程间共享属性： 设置时钟属性： pthread_cond_timewait函数用于在等待条件变量时提供超时功能，不过该函数的超时时间是一个绝对时间。默认使用系统时间，这意味着若修改系统时间，那么超时就不准确：有可能提前返回，也可能要几年才返回。这在某些情况下会导致bug，这时我们可以通过设置条件变量的时钟属性来避免这个问题。下面的例子展示了如何使用这个属性：

利用管程实现同步时，还应设置条件变量和在条件变量上进行操作的两个同步原语。条件变量用于区别各种不同的等待原因。其说明形式为： condition ： x，y;同步原语wait和signal。wait使调用进程等待，并将它排在相应的等待队列上;signal唤醒等待队列的队首进程。使用方式为：x.wait，x.signal。

含义是在管程中设置变量控制线程的执行，作用是区分阻塞原因。管程为何种阻塞的原因设置了条件变量，进程若因此原因而阻塞，会把进程挂在此条件变量的队列上，若是阻塞条件发生变换，则启动一个进程；作用是解决管程中的进程不能被阻塞，而其他进程不能访问管程的问题。

注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候，才能注销这个条件变量，否则返回EBUSY。API定义如下：int pthread_cond_destroy(pthread_cond_t *cond)注：头文件为#include <pthread.h>

信号量强调的是线程（或进程）间的同步：“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都 在sem_wait的时候，就阻塞在那里）。当信号量为单值信号量是，也可以完成一个资源的互斥访问。　　　　有名信号量：可以用于不同进程间或多线程间的互斥与同步　　创建打开有名信号量　　sem_t *sem_open(const char *name, int oflag);　　sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);　　　　成功返回信号量指针；失败返回SEM_FAILED，设置errnoname是文件路径名,但不能写成/tmp/a.sem这样的形式,因为在linux下,sem都是在/dev/shm目录下,可写成"/mysem"或"mysem",创建出来的文件都 是"/dev/shm/sem.mysem",mode设置为0666，value设置为信号量的初始值.所需信号灯等已存在条件下指定O_CREAT|O_EXCL却是个错误。　　　　关闭信号量，进程终止时，会自动调用它　　int sem_close(sem_t *sem);　　成功返回0；失败返回-1，设置errno　　　　删除信号量，立即删除信号量名字，当其他进程都关闭它时，销毁它　　int sem_unlink(const char *name);　　　　等待信号量，测试信号量的值，如果其值小于或等于0，那么就等待（阻塞）；一旦其值变为大于0就将它减1，并返回　　int sem_wait(sem_t *sem);　　int sem_trywait(sem_t *sem);　　　　成功返回0；失败返回-1，设置errno　　　　当信号量的值为0时，sem_trywait立即返回，设置errno为EAGAIN。如果被某个信号中断，sem_wait会过早地返回，设置errno为EINTR　　　　发出信号量，给它的值加1，然后唤醒正在等待该信号量的进程或线程　　int sem_post(sem_t *sem);　　　　成功返回0；失败返回-1，不会改变它的值，设置errno，该函数是异步信号安全的，可以在信号处理程序里调用它无名信号量，用于进程体内各线程间的互斥和同步,使用如下API(无名信号量,基于内存的信号量)　　　　（1）、sem_init　　　　功能：用于创建一个信号量，并初始化信号量的值。　　　　头文件：　　　　函数原型： int sem_init (sem_t* sem, int pshared, unsigned int value);　　　　函数传入值： sem:信号量。pshared:决定信号量能否在几个进程间共享。由于目前LINUX还没有实现进程间共享信息量，所以这个值只能取0。　　　　（2）其他函数。　　int sem_wait (sem_t* sem);　　int sem_trywait (sem_t* sem);　　int sem_post (sem_t* sem);　　int sem_getvalue (sem_t* sem);　　int sem_destroy (sem_t* sem);　　　　功能：sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。sem_post相当于V操作，它将信号量的值加一，同时发出唤醒的信号给等待的进程（或线程）。　　　　sem_getvalue 得到信号量的值。　　　　sem_destroy 摧毁信号量。　　　　如果某个基于内存的信号灯是在不同进程间同步的，该信号灯必须存放在共享内存区中，这要只要该共享内存区存在，该信号灯就存在。　　　　互斥锁(又名互斥量）强调的是资源的访问互斥：互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的”　　　　也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。在有些情况下两者可以互换。　　　　在linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:　　　　对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.　　　　对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.　　原型:　　int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);　　int pthread_mutex_destroy(pthread_mutex_t *mutex);　　　　头文件:　　　　返回值: 成功则返回0, 出错则返回错误编号.　　　　说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.　　　　首先说一下加锁函数:　　　　头文件:　　int pthread_mutex_lock(pthread_mutex_t *mutex);　　int pthread_mutex_trylock(pthread_mutex_t *mutex);　　　　返回值: 成功则返回0, 出错则返回错误编号.　　　　说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量 被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.　　　　再说一下解所函数:　　　　头文件:　　原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);　　　　返回值: 成功则返回0, 出错则返回错误编号.　　　　条件变量常与互斥锁同时使用，达到线程同步的目的：条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足。在发 送信号时，如果没有线程 等待在该条件变量上，那么信号将丢失；而信号量有计数值，每次信号量post操作都会被记录　　　　1. 互斥锁必须是谁上锁就由谁来解锁，而信号量的wait和post操作不必由同一个线程执行。　　　　2. 互斥锁要么被锁住，要么被解开，和二值信号量类似　　　　3. sem_post是各种同步技巧中，唯一一个能在信号处理程序中安全调用的函数　　　　4. 互斥锁是为上锁而优化的；条件变量是为等待而优化的； 信号量既可用于上锁，也可用于等待，因此会有更多的开销和更高的复杂性　　　　5. 互斥锁，条件变量都只用于同一个进程的各线程间，而信号量（有名信号量）可用于不同进程间的同步。当信号量用于进程间同步时，要求信号量建立在共享内存区。　　　　6. 信号量有计数值，每次信号量post操作都会被记录，而条件变量在发送信号时，如果没有线程在等待该条件变量，那么信号将丢失。　　　　读写锁　　　　读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。　　　　读写锁可以由三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写　　锁。　　　　在读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。虽然读写锁的实现各不相同，但当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。　　　　读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为当前只有一个线程可以在写模式下拥 有这个锁。当读写锁在读状态下时，只要线程获取了读模式下的读写锁，该锁所保护的数据结构可以被多个获得读模式锁的线程读取。　　　　读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的；当他以写模式锁住时，它是以独占模式锁住的。　　初始化和销毁:　　#include　　int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);　　int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);　　　　成功则返回0, 出错则返回错误编号.　　　　同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过thread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.　　　　读和写:　　#include　　int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);　　int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);　　int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);　　　　成功则返回0, 出错则返回错误编号.　　　　这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:　　#include　　int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);　　int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);　　　　成功则返回0, 出错则返回错误编号.　　　　非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.　　　　虽然读写锁提高了并行性，但是就速度而言并不比互斥量快.　　　　可能这也是即使有读写锁存在还会使用互斥量的原因，因为他在速度方面略胜一筹。这就需要我们在写程序的时候综合考虑速度和并行性并找到一个折中。　　　　比如： 假设使用互斥量需要0.5秒，使用读写锁需要0.8秒。在类似学生管理系统这类软件中，可能百分之九十的时间都是查询操作，那么假如现在突然来个个20个请求，如果使用的是互斥量，那么最后的那个查询请求被满足需要10后。这样，估计没人能受得了。而使用读写锁，应为 读锁能够多次获得。所以所有的20个请求，每个请求都能在1秒左右得到满足。　　　　也就是说，在一些写操作比较多或是本身需要同步的地方并不多的程序中我们应该使用互斥量，而在读操作远大于写操作的一些程序中我们应该使用读写锁来进行同步　　　　条件变量(condition)　　　　条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。　　　　条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其它线程在获得互斥量之前不会察觉到这种改变，因此必须锁定互斥量以后才能计算条件。　　　　条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件　　　　变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。　　　　1. 初始化:　　　　条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:　　　　静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.　　动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.　　#include　　int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);　　int pthread_cond_destroy(pthread_cond_t *cond);　　　　成功则返回0, 出错则返回错误编号.　　　　注意：条件变量占用的空间并未被释放。　　　　当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.　　　　2. 等待条件:　　#include　　int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);　　int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);　　　　成功则返回0, 出错则返回错误编号.　　　　这两个函数分别是阻塞等待和超时等待.　　　　等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样 便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.　　　　当pthread_cond_wait返回时, 互斥量再次被锁住.　　　　pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。　　　　pthread_cond_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。　　　　阻塞在条件变量上的线程被唤醒以后，直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条 件值。最好的测试方法是循环调用pthread_cond_wait函数，并把满足条件的表达式置为循环的终止条件。如：　　　　pthread_mutex_lock();　　　　while (condition_is_false)　　　　pthread_cond_wait();　　　　pthread_mutex_unlock();　　　　阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。　　　　注意：pthread_cond_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条 件变量相关的互斥锁仍将处在锁定状态。　　　　pthread_cond_timedwait函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。　　　　注意：pthread_cond_timedwait函数也是退出点。　　　　超时时间参数是指一天中的某个时刻。使用举例：　　　　pthread_timestruc_t to;　　　　to.tv_sec = time(NULL) + TIMEOUT;　　　　to.tv_nsec = 0;　　　　超时返回的错误码是ETIMEDOUT。　　　　3. 通知条件:　　#include　　int pthread_cond_signal(pthread_cond_t *cond);　　int pthread_cond_broadcast(pthread_cond_t *cond);　　　　成功则返回0, 出错则返回错误编号.　　　　这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

信号量、共享内存,以及消息队列等System V IPC三剑客主要关注进程间通信; 而条件变量、互斥锁,主要关注线程间通信。

互斥锁一个明显的缺点是他只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，他常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其他的某个线程改变了条件变量，他将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线承间的同步。

公式前面都没问题，到10这个以后就抓取出错了，是公式哪里问题吗？我自己重新更改好了，请各位朋友参考=IF(A1=1,50,IF(A1=2,100,IF(A1=3,150,IF(A1=4,200,IF(A1=5,250,IF(A1=6,300,IF(A1=7,350,IF(A1=8,400,IF(A1=9,450,IF(A1≥10,500))))))))))

条件变量（Condition Variable）是一种同步工具，允许线程暂停执行、进入休眠，直到某些共享资源满足条件。条件变量基本操作如下： 条件锁体现的是一种协作，一个线程完成后通知其他线程开始执行。Condition variable 必须和 mutex 关联，以避免竞争条件。一个线程获取锁后发现条件不满足，暂停线程执行进行等待，其他线程这时可以获取锁，条件满足后，向条件发出信号。 条件锁可用于生产者、消费者模式中状态同步： 当消费者发现没有数据时，等待 condition 变为1。生产者生产了新数据，condition 变为1，通知消费者。 这篇文章将介绍三种条件锁： pthread_cond_t 、 NSCondition 和 NSConditionLock 。 前面两篇文章已介绍过 pthread_mutex_t 和 pthread_mutexattr_t ，这里需额外使用 pthread_cond_t 。 使用 pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr) 初始化条件变量 cond，cond_attr 指定的 condition attribute。如果 cond_attr 为 nil，则使用默认属性。 pthread_cond_t 也可以使用PTHREAD_COND_INITIALIZER常量静态初始化。 如下所示： pthread_cond_signal() 和 pthread_cond_broadcast() 函数用于解除堵塞在条件变量上的线程。 如果多个线程堵塞在 cond，调度器决定唤醒哪个线程。使用 pthread_cond_signal() 、 pthread_cond_broadcast() 唤醒线程后，从 pthread_cond_wait() 和 pthread_cond_timedwait() 返回的线程会尝试持有 mutex。如果没有线程等待 cond，则什么也不发生。 pthread_cond_wait() 和 pthread_cond_timedwait() 函数用于堵塞条件变量。需先使用同一线程锁定 mutex，否则会导致无法预期结果。 解锁 mutex 与在条件变量处挂起线程是原子操作。线程先获取 mutex、后 signal 条件变量，可以避免线程在加锁后、等待条件变量前被唤醒。线程被挂起后不再占用 CPU 时间，直到 signal 条件变量。成功返回后，mutex 被该线程持有。 多个 mutex 并发使用同一个 condition variable 会产生无法预期的结果。也就是当线程等待 condition variable 时， cond 就绑定到了该 mutex。等待结束时，绑定关系终止。 pthread_cond_timedwait() 与 pthread_cond_wait() 类似，只是如果指定时间后还没有 signal、broadcast，就返回错误。 pthread_cond_destroy() 销毁指定cond，销毁后对象成为未初始化状态。销毁后的对象可以使用 pthread_cond_init() 再次初始化，其他方式使用已销毁的对象会产生无法预期的结果。 NSCondition 类是对 pthread_mutex_t 和 pthread_cond_t 的封装，为面向对象的类。 NSCondition 类遵守 NSLocking 协议。 初始化方法如下： GNUstep 中实现如下： signal() 一次唤醒一个线程，可以多次调用唤醒多个线程。 broadcast() 一次唤醒多个线程。 如果没有线程等待cond，则不执行任何操作。为避免竞争条件，应只在 condtion 锁定时调用。 GNUstep 中实现如下： 堵塞当前线程，直到 signal 或到达指定时间。必须先 lock NSCondition 再调用该方法。 GNUstep 中实现如下： NSConditionLock 类是对 pthread_mutex_t 和 pthread_cond_t 的封装，为面向对象的类，方。 NSConditionLock 类遵守 NSLocking 协议。 NSConditionLock 有一个关联值，即condition。在初始化 NSConditionLock 或释放锁时设置。线程会等待锁，直到其为特定值，等待期间不会占用 CPU 时间。借助 NSConditionLock condition值可以实现依赖项，使其按次序执行。 初始化方法如下： GNUstep 中实现如下： 当 NSConditionLock 的condition值与 lock(whenCondition:) 参数的值相同时，加锁成功，否则会堵塞在当前位置。 GNUstep 中实现如下： 释放锁，并设置 condition 值。 现在，上述三个方法按顺序执行。 GNUstep 中实现如下： Demo名称：Synchronization 源码地址： https://github.com/pro648/BasicDemos-iOS/tree/master/Synchronization 参考资料： 欢迎更多指正： https://github.com/pro648/tips 本文地址： https://github.com/pro648/tips/blob/master/sources/线程同步之条件锁.md

首先，你这个公式的最后一个IF那里，A1大于等于10，这个地方应该是A2吧，你是不是自己写错了？另外，这个大于等于号不对，你可以用我这个公式：=IF(A2=1,50,IF(A2=2,100,IF(A2=3,150,IF(A2=4,200,IF(A2=5,250,IF(A2=6,300,IF(A2=7,350,IF(A2=8,400,IF(A2=9,450,500))))))))

t期因变量和t-1期变量回归：“选择变量”即是条件变量，并且有个条件定义按钮（rule），通过这个按钮可以给定一个条件，只有变量值满足这个条件的样本数据才参与回归分析。一元线性回归方程y=ax+b，系数a＞0，y与x正相关，x高时，y高，x低时，y低，a＜0相反。二元线性回归方程是y=ax1+bx2+c，x1，x2对应本题的A、B变量。如果系数a，b都是正的，那么就是A高B高时，C也会高；如果系数是负值，那么就A高B高时，C会低；如果系数a为正，b为负，那么A高，B低，C会高，但A低B高，效应相减，C的高低就难确定了。定义一元线性回归分析预测法，是根据自变量x和因变量Y的相关关系，建立x与Y的线性回归方程进行预测的方法。由于市场现象一般是受多种因素的影响，而并不是仅仅受一个因素的影响。所以应用一元线性回归分析预测法，必须对影响市场现象的多种因素做全面分析。只有当诸多的影响因素中，确实存在一个对因变量影响作用明显高于其他因素的变量，才能将它作为自变量，应用一元相关回归分析市场预测法进行预测。

随机唤醒一个在等待的线程

condition表示做某事或达成某个目标必须具备的条件. 而situation是表示某人所处的环境或者是目前的整体情况或态势,形势. 这个从上下文的语境中可以做出判断.

不对，现场试验也存在很多变数，很多事情是控制不了的！

spss中的多元logistic回归中的协变量定义：在实验的设计中，协变量是一个独立变量（解释变量），不为实验者所操纵，但仍影响实验结果。协变量是指那些人为很难控制的变量，通常在回归分析中要排除这些因素对结果的影响。“选择变量”即是条件变量，并且有个条件定义按钮（rule），通过这个按钮可以给定一个条件，只有变量值满足这个条件的样本数据才参与回归分析。协变量（covariate）在心理学、行为科学中，是指与因变量有线性相关并在探讨自变量与因变量关系时通过统计技术加以控制的变量。

管程由三部分组成:局部于管程的共享变量说明；对该数据结构进行操作的一组过程；对局部于管程的 数据设置初始值的语句.(图见P80) 因为调用wait原语后,使进程等待的原因有多种,为了区别它们,引入了条件变量.

if判断条件正确后，对条件变量进行赋值可以用赋值语句。书写合格的程序代码，是进行程序设计的根本。熟练地掌握了这些内容，在以后的编程中才不会捉襟见肘。编程的语法就像人类语言的语法一样，是用一些词汇和词汇的组织规则来表达自己的。VisualBasic的程序代码由语句、常数和声明等部分组成。使用最频繁的语句是赋值语句，在程序运行的过程中改变对象的属性、变量的值。语法如下：对象.属性或变量=表达式赋值语句是把等号右边表达式的值赋给等号左边的变量或对象的属性。

现场实验可以严格控制条件变量。这个是对的。因为实验的条件是由我们人去设置的。

什么是惊群，这篇文章写的很好： 举一个很简单的例子，当你往一群鸽子中间扔一块食物，虽然最终只有一个鸽子抢到食物，但所有鸽子都会被惊动来争夺，没有抢到食物的鸽子只好回去继续睡觉， 等待下一块食物到来。这样，每扔一块食物，都会惊动所有的鸽子，即为 惊群 。对于操作系统来说，多个进程/线程在等待同一资源是，也会产生类似的效果，其结 果就是每当资源可用，所有的进程/线程都来竞争资源，造成的后果： 参考 1）系统对用户进程/线程频繁的做无效的调度、上下文切换，系统系能大打折扣。 2）为了确保只有一个线程得到资源，用户必须对资源操作进行加锁保护，进一步加大了系统开销。 对于惊群效应的场景描述，最常见的就是对于socket操作符的accept操作的描述。当多个用户进程/线程同时监听同一个端口时，由于实际上一个请求过来，只有一个进程/线程accept成功，所以就会产生惊群效应。 实际上这是一个很古老的问题。linux操作系统在内核层面很早就解决了这个问题，一个请求过来，内核只会唤醒一个进程来accept，这样就没有惊群现象了。但是在很多场景下，只要有竞争，就可能会出现惊群效应。比如常见的生产者-消费者模型，一般来说消费可能会比较耗时，所以消费者会有多个。当突然有生产者往队列里面投了一个job时，这些消费者就会一哄而上去队列中抢这个job，这就发生了惊群效应。 一个基本的线程池框架也是基于生产者-消费者模型的。也就是说只要用到了进程池或者线程池，你可能就避免不了要处理惊群效应带来的问题。所以 你能感觉到惊群效应的无处不在了吗 。。。 那么对于线程池这个模型，我们怎么解决它可能出现的惊群问题呢？ 一个线程池的定义一般如上所示：有最大线程数限制max_threads，当前线程数curr_threads和空闲线程数idle_threads，然后还有线程互斥锁，还有线程条件变量， 每个线程条件变量对应一个唯一线程 ，然后还有一个线程任务队列(链表)。为什么需要线程条件变量和线程任务队列这些？？ 消费者一般在等待任务和处理任务的过程中，处理逻辑可以简化为： 如果生产者有任务了，就会通过内核通知消费者。生产者的通知过程可简化为： 注意上面用的是pthread_cond_signal，这个是根据进程条件变量来通知某一个等待消费的线程，而不是用pthread_cond_broadcast函数来广播给所有等待任务的消费者，这样就不会产生惊群效应。 pthread_cond_signal函数的作用上面也说了，是根据条件变量发送信号给一个正在休眠等待消费的线程，这个休眠消费线程获取到这个信号后马上激活，进行消费。 如果某一时刻，所有的消费线程都在进行各自的消费，此时又有一个生产者发送了一个任务，现在没有空闲消费者来接怎么办？？ 在这种情况下，生产者调用pthread_cond_signal函数也会立刻返回，只不过此时不是根据条件变量通知一个消费线程来accept，而是将此任务放到线程池队列中去，等待有空闲的消费线程过来取。 上面说了一个条件变量对应一个消费线程（意思就是每次都能根据当时的条件找到唯一的一个消费进程），那条件变量到底是什么呢？？ 条件变量的作用就是筛选出一个最合适的消费线程。那生产者生产了一个任务后，是怎么根据条件变量筛选出那个最合适的消费线程的呢？？ 假设有多个消费线程正在休眠，首先根据各消费线程优先级的高低确定哪个线程接收到信号开始继续执行。如果各线程优先级相同，则根据等待时间的长短来确定哪个线程获得信号。 在上面这种机制下，我们能保证生产者生产了一个任务后只会通知唯一的一个消费者线程，所以不会出现惊群效应。等等，到目前为止，咱们定义的线程池中，pthread_mutex好像并没有用到呢？？ 刚刚我们只是假设有pthread_cond_signal这种函数来保证每个任务只通知一个唯一的消费进程，那如果有的系统没有这样的单一通知机制，只有pthread_cond_broadcast函数这种广播机制怎么办？？ 此时pthread_mutex这个线程池互斥锁便派上用场了。在只有pthread_cond_broadcast函数这种广播机制的情况下，通过一个线程互斥锁，给每一个消费者线程创建一个条件变量......（好像原文后面说的不是很清楚） 【大意】：在线程池中，增加一组线程条件变量，对应于每一个线程。增加任务的时候，如果有空闲线程，那么只通知某一个空闲线程，并且将其置忙。忙与闲，可以通过条件变量来表征，用一个链表表示(类似连接池)。 如果所有线程都忙，那么就将任务加入全局队列，并且通知所有消费者（这时惊群是很小的，除非所有线程都刚好同一时刻完成任务，同一时刻争夺资源，否则只有极少数线程会发生惊群）。 上面也说道了linux在操作系统层已经避免了惊群效应的出现，但是nginx作为一个移植性非常高的web服务器，它自己也实现了一套避免出现惊群效应的机制。

三种专门用于线程同步的机制:POSIX信号量,互斥量和条件变量. 在Linux上信号量API有两组,一组是System V IPC信号量,即PV操作,另外就是POSIX信号量,POSIX信号量的名字都是以sem_开头. phshared参数指定信号量的类型,若其值为0,就表示这个信号量是当前进程的局部信号量,否则该信号量可以在多个进程之间共享.value值指定信号量的初始值,一般与下面的sem_wait函数相对应. 其中比较重要的函数sem_wait函数会以原子操作的方式将信号量的值减一,如果信号量的值为零,则sem_wait将会阻塞,信号量的值可以在sem_init函数中的value初始化;sem_trywait函数是sem_wait的非阻塞版本;sem_post函数将以原子的操作对信号量加一,当信号量的值大于0时,其他正在调用sem_wait等待信号量的线程将被唤醒. 这些函数成功时返回0,失败则返回-1并设置errno. 生产者消费者模型: 生产者对应一个信号量:sem_t producer; 消费者对应一个信号量:sem_t customer; sem_init(&producer,2)----生产者拥有资源,可以工作; sem_init(&customer,0)----消费者没有资源,阻塞; 在访问公共资源前对互斥量设置（加锁），确保同一时间只有一个线程访问数据，在访问完成后再释放（解锁）互斥量. 互斥锁的运行方式:串行访问共享资源; 信号量的运行方式:并行访问共享资源; 互斥量用pthread_mutex_t数据类型表示，在使用互斥量之前，必须使用pthread_mutex_init函数对它进行初始化，注意，使用完毕后需调用pthread_mutex_destroy. pthread_mutex_init用于初始化互斥锁，mutexattr用于指定互斥锁的属性，若为NULL，则表示默认属性。除了用这个函数初始化互斥所外，还可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER。 pthread_mutex_destroy用于销毁互斥锁，以释放占用的内核资源，销毁一个已经加锁的互斥锁将导致不可预期的后果。 pthread_mutex_lock以原子操作给一个互斥锁加锁。如果目标互斥锁已经被加锁，则pthread_mutex_lock则被阻塞，直到该互斥锁占有者把它给解锁. pthread_mutex_trylock和pthread_mutex_lock类似，不过它始终立即返回，而不论被操作的互斥锁是否加锁，是pthread_mutex_lock的非阻塞版本.当目标互斥锁未被加锁时，pthread_mutex_trylock进行加锁操作；否则将返回EBUSY错误码。注意：这里讨论的pthread_mutex_lock和pthread_mutex_trylock是针对普通锁而言的，对于其他类型的锁，这两个加锁函数会有不同的行为. pthread_mutex_unlock以原子操作方式给一个互斥锁进行解锁操作。如果此时有其他线程正在等待这个互斥锁，则这些线程中的一个将获得它. 三个打印机轮流打印: 输出结果: 如果说互斥锁是用于同步线程对共享数据的访问的话,那么条件变量就是用于在线程之间同步共享数据的值.条件变量提供了一种线程之间通信的机制:当某个共享数据达到某个值时,唤醒等待这个共享数据的线程. 条件变量会在条件不满足的情况下阻塞线程.且条件变量和互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生. 其中pthread_cond_broadcast函数以广播的形式唤醒所有等待目标条件变量的线程,pthread_cond_signal函数用于唤醒一个等待目标条件变量线程.但有时候我们可能需要唤醒一个固定的线程,可以通过间接的方法实现:定义一个能够唯一标识目标线程的全局变量,在唤醒等待条件变量的线程前先设置该变量为目标线程,然后采用广播的方式唤醒所有等待的线程,这些线程被唤醒之后都检查该变量以判断是否是自己. 采用条件变量+互斥锁实现生产者消费者模型: 运行结果: 阻塞队列+生产者消费者 运行结果:

不要认为LATEX语言的功能很简单，它也可以定义选择分支。通过本文的讲解，我们可以熟悉如何定义一个条件变量，如何使用一个条件变量，从而让我们的代码具有更大的灵活性。定义条件变量看例子： ewififsysuthesisthankssysuthesisthanksfalse上面定义了一个条件变量sysuthesisthanks，并将其的默认值设为false。要留意它的语法细节与其他语言的区别。使用条件变量下面看如何使用前面定义的条件变量sysuthesisthanks。代码例 ewcommand{sysuthesis@thanks}{} enewcommand{ hanks}[1]{sysuthesisthankstrue enewcommand{sysuthesis@thanks}{#1}}上面定义了一个命令 hanks，它带有一个参数，该命令的功能为：将条件变量sysuthesisthanks设置为true，同时重定义命令sysuthesis@thanks（详细语法细节参见《一种LaTeX类文件 (cls) 与主文件 (tex)的参数传递方法》）。接下来，在cls文件中继续使用条件变上面代码的含义是：如果条件变量sysuthesisthanks的值为true，则做相应的执行，即输出一个footnote。LaTeX（LATEX，音译“拉泰赫”）是一种基于ΤΕΧ的排版系统，由美国计算机学家莱斯利·兰伯特（Leslie Lamport）在20世纪80年代初期开发，利用这种格式，即使使用者没有排版和程序设计的知识也可以充分发挥由TeX所提供的强大功能，能在几天，甚至几小时内生成很多具有书籍质量的印刷品。对于生成复杂表格和数学公式，这一点表现得尤为突出。因此它非常适用于生成高印刷质量的科技和数学类文档。这个系统同样适用于生成从简单的信件到完整书籍的所有其他种类的文档。LaTeX使用TeX作为它的格式化引擎，当前的版本是LaTeX2ε。

单击select按钮，选择一个变量作为条件变量到selection variable框中，并单击rule按钮给定一个判断条件。它的作用：只有条件变量值满足给定条件的样本数据才参与回归分析。

实际上因为可以做一般傅里叶变换(非广义傅里叶变换)的函数一定是决对可积的满足狄利克雷条件的函数，这类函数一般都是有自变量趋于无穷函数值就趋于0

situation和condition的区别：意思不同、用法不同、侧重点不同一、意思不同1.situation意思：n. 情况; 状况; 形势; 局面; (建筑物或城镇的)地理位置，环境特点; 职业; 工作岗位;2.condition意思：n. 状态; 状况; 健康状况; (因不可能治愈而长期患有的)疾病; v. 训练; 使习惯于; 使适二、用法不同1.situation用法：表示人或事物的名称。例句：The overall situation is worsening.整体形势在日益恶化。2.condition用法：可以做主语、宾语、同位语、表语 、定语、状语、补语。例句：Conditions in poor quarters were horrible.城里穷人居住区条件十分糟糕。三、侧重点不同1.situation侧重点：situation主要是指各种情况之间的相互关系，着重与形势或局面。2.condition侧重点：condition与周围环境有关，着重于条件或境况。

经济学模型有很多，没有确定的多少种。包括宏观经济学、微观经济学、国际经济学、流通经济学、计量经济学等等，各门课中都有许多相关的经济学模型。如生产模型，索洛模型，罗默模型，IS_ID模型、是IS-LM-BP模型，总需求-总供给模型和蒙代尔弗莱明模型等等。经济模型是一种分析方法，它极其简单地描述现实世界的情况。现实世界的情况是由各种主要变量和次要变量构成的，非常错综复杂，因而除非把次要的因素排除在外，否则就不可能进行严格的分析，或使分析复杂得无法进行。通过作出某些假设，可以排除许多次要因子，从而建立起模型。这样一来，便可以通过模型对假设所规定的特殊情况进行分析。经济模型本身可以用带有图表或文字的方程来表示。理论模型的设计在单方程模型中，变量分为两类。作为研究对象的变量，也就是因果关系中的“果”，例如生产函数中的产出量，是模型中的被解释变量；而作为“原因”的变量，例如生产函数中的资本、劳动、技术，是模型中的解释变量。确定模型所包含的变量，主要是指确定解释变量。可以作为解释变量的有下列几类变量：外生经济变量、外生条件变量、外生政策变量和滞后被解释变量。其中有些变量，如政策变量、条件变量经常以虚变量的形式出现。以上内容参考：百度百科-计量经济模型

一、理论模型的设计对所要研究的经济现象进行深入的分析，根据研究的目的，选择模型中将包含的因素，根据数据的可得性选择适当的变量来表征这些因素，并根据经济行为理论和样本数据显示出的变量间的关系，设定描述这些变量之间关系的数学表达式，即理论模型。例如上节中的生产函数就是一个理论模型。理论模型的设计主要包含三部分工作，即选择变量、确定变量之间的数学关系、拟定模型中待估计参数的数值范围。1.确定模型所包含的变量在单方程模型中，变量分为两类。作为研究对象的变量，也就是因果关系中的“果”，例如生产函数中的产出量，是模型中的被解释变量；而作为“原因”的变量，例如生产函数中的资本、劳动、技术，是模型中的解释变量。确定模型所包含的变量，主要是指确定解释变量。可以作为解释变量的有下列几类变量：外生经济变量、外生条件变量、外生政策变量和滞后被解释变量。其中有些变量，如政策变量、条件变量经常以虚变量的形式出现。严格他说，上述生产函数中的产出量、资本、劳动、技术等，只能称为“因素”，这些因素间存在着因果关系。为了建立起计量经济学模型，必须选择适当的变量来表征这些因素，这些变量必须具有数据可得性。于是，我们可以用总产值来表征产出量，用固走资产原值来表征资本，用职工人数来表征劳动，用时间作为一个变量来表征技术。这样，最后建立的模型是关于总产值、固定资产原值、职工人数和时间变量之间关系的数学表达式。下面，为了叙述方便，我们将“因素”与“变量”间的区别暂时略去，都以“变量”来表示。关键在于，在确定了被解释变量之后，怎样才能正确地选择解释变量。首先，需要正确理解和把握所研究的经济现象中暗含的经济学理论和经济行为规律。这是正确选择解释变量的基础。例如，在上述生产问题中，已经明确指出属于供给不足的情况，那么，影响产出量的因素就应该在投入要素方面，而在当前，一般的投入要素主要是技术、资本与劳动。如果属于需求不足的情况，那么影响产出量的因素就应该在需求方面，而不在投入要素方面。这时，如果研究的对象是消费品生产，应该选择居民收入等变量作为解释变量；如果研究的对象是生产资料生产，应该选择固定资产投资总额等变量作为解释变量。由此可见，同样是建立生产模型，所处的经济环境不同、研究的行业不同，变量选择是不同的。其次，选择变量要考虑数据的可得性。这就要求对经济统计学有透彻的了解。计量经济学模型是要在样本数据，即变量的样本观测值的支持下，采用一定的数学方法估计参数，以揭示变量之间的定量关系。所以所选择的变量必须是统计指标体系中存在的、有可靠的数据来源的。如果必须引入个别对被解释变量有重要影响的政策变量、条件变量，则采用虚变量的样本观测值的选取方法。第三，选择变量时要考虑所有入选变量之间的关系，使得每一个解释变量都是独立的。这是计量经济学模型技术所要求的。当然，在开始时要做到这一点是困难的，如果在所有入选变量中出现相关的变量，可以在建模过程中检验并予以剔除。从这里可以看出，建立模型的第一步就已经体现了计量经济学是经济理论、经济统计学和数学三者结合的思想。在选择变量时，错误是容易发生的。下面的例子都是从已有的计量经济学应用研究成果中发现的，代表了几类容易发生的错误。例如农副产品出口额＝-107.66＋0.13×社会商品零售总额十0.22×农副产品收购额这里选择了无关的变量，因为社会商品零售总额与农副产品出口额无直接关系，更不是影响农副产品出口额的原因。再如生产资料进口额＝0.73×轻工业投资＋0.21×出口额＋0.18×生产消费＋67.60×进出口政策这里选择了不重要的变量，因为轻工业投资对生产资料进口额虽有影响，但不是重要的，或者说是不完全的，重要的是全社会固定资产投资额，应该选择这个变量。再如农业总产值＝0.78＋0.24×粮食产量＋0.05×农机动力—0.21×受灾面积这里选择了不独立的变量，因为粮食产量是受农机动力和受灾面积影响的，它们之间存在相关性。值得注意的是上述几个模型都能很好地拟合样本数据，所以绝对不能把对样本数据的拟合程度作为判断模型变量选择是否正确的主要标准。变量的选择不是一次完成的，往往要经过多次反复。2.确定模型的数学形式选择了适当的变量，接下来就要选择适当的数学形式描述这些变量之间的关系，即建立理论模型。选择模型数学形式的主要依据是经济行为理论。在数理经济学中，已经对常用的生产函数、需求函数、消费函数、投资函数等模型的数学形式进行了广泛的研究，可以借鉴这些研究成果。需要指出的是，现代经济学尤其注重实证研究，任何建立在一定经济学理论假设基础上的理论模型，如果不能很好地解释过去，尤其是历史统计数据，那么它是不能为人们所接受的。这就要求理论模型的建立要在参数估计、模型检验的全过程中反复修改，以得到一种既能有较好的经济学解释又能较好地反映历史上已经发生的诸变量之间关系的数学模型。忽视任何一方面都是不对的。也可以根据变量的样本数据作出解释变量与被解释变量之间关系的散点图，由散点图显示的变量之间的函数关系作为理论模型的数学形式。这也是人们在建模时经常采用的方法。在某些情况下，如果无法事先确定模型的数学形式，那么就采用各种可能的形式进行试模拟，然后选择模拟结果较好的一种。3.拟定理论模型中待估参数的理论期望值理论模型中的待估参数一般都具有特定的经济含义，它们的数值，要待模型估计、检验后，即经济数学模型完成后才能确定，但对于它们的数值范围，即理论期望值，可以根据它们的经济含义在开始时拟定。这一理论期望值可以用来检验模型的估计结果。拟定理论模型中待估参数的理论期望值，关键在于理解待估参数的经济含义。例如上述生产函数理论模型中有4个待估参数和α、β、γ和A。其中，α是资本的产出弹性，β是劳动的产出弹性，γ近似为技术进步速度，A是效率系数。根据这些经济含义，它们的数值范围应该是于集中的问题。经济变量在时间序列上的变化往往是缓慢的，例如，居民收入每年的变化幅度只有5%左右。如果在一个消费函数模型中，以居民消费作为被解释变量，以居民收入作为解释变量，以它的时间序列数据作为解释变量的样本数据，由于样本数据过于集中，所建立的模型很难反映两个变量之间的长期关系。这也是时间序列不适宜于对模型中反映长期变化关系的结构参数的估计的一个主要原因。四是模型随机误差项的序列相关问题。用时间序列数据作样本，容易引起模型随机误差项产生序列相关。这个问题后面还要专门讨论。截面数据是一批发生在同一时间截面上的调查数据。例如，工业普查数据、人口普查数据、家计调查数据等，主要由统计部门提供。用截面数据作为计量经济学模型的样本数据，应注意以下几个问题。一是样本与母体的一致性问题。计量经济学模型的参数估计，从数学上讲，是用从母体中随机抽取的个体样本估计母体的参数，那么要求母体与个体必须是一致的。例如，估计煤炭企业的生产函数模型，只能用煤炭企业的数据作为样本，不能用煤炭行业的数据。那么，截面数据就很难用于一些总量模型的估计，例如，建立煤炭行业的生产函数模型，就无法得到合适的截面数据。二是模型随机误差项的异方差问题。用截面数据作样本，容易引起模型随机误差项产生异方差。这个问题后面还要专门讨论。虚变量数据也称为二进制数据，一般取0或1。虚变量经常被用在计量经济学模型中，以表征政策、条件等因素。例如，建立我国的粮食生产计量经济学模型，以粮食产量作为被解释变量，解释变量中除了播种面积、化肥使用量、农机总动力、成灾面积等变量外，显然，政策因素是不可忽略的。1980年前后，由于实行了不同的政策，即使上述变量都没有变化，粮食产量也会发生大的变化。于是必须在解释变量中引人政策变量，用一个虚变量表示，对于1980年以后的年份，该虚变量的样本观测值为1，对于1980年以前的年份，该虚变量的样本观测值为0。也可以取0、l以外的数值，表示该因素的变化程度。例如，在工业生产模型中用虚变量表示气候对工业生产的影响，可以将不同年份气候的影响程度，分别用0、1、-1，甚至0.5、-0.5等表示。不过，这种方法应慎用，以免违背客观性。2.样本数据的质量样本数据的质量问题大体上可以概括为完整性、准确性、可比性和一致性四个方面。完整性，即模型中包含的所有变量都必须得到相同容量的样本观测值。这既是模型参数估计的需要，也是经济现象本身应该具有的特征。但是，在实际中，“遗失数据”的现象是经常发生的，尤其在中国，经济体制和核算体系都处于转轨之中。在出现“遗失数据”时，如果样本容量足够大，样本点之间的联系并不紧密的情况下，可以将“遗失数据”所在的样本点整个地去掉；如果样本容量有限，或者样本点之间的联系紧密，去掉某个样本点会影响模型的估计质量，则要采取特定的技术将“遗失数据”补上。准确性，有两方面含义，一是所得到的数据必须准确反映它所描述的经济因素的状态，即统计数据或调查数据本身是准确的；二是它必须是模型研究中所准确需要的，即满足模型对变量口径的要求。前一个方面是显而易见的，而后一个方面则容易被忽视。例如，在生产函数模型中，作为解释变量的资本、劳动等必须是投入到生产过程中的、对产出量起作用的那部分生产要素，以劳动为例，应该是投入到生产过程中的、对产出量起作用的那部分劳动者。于是，在收集样本数据时，就应该收集生产性职工人数，而不能以全体职工人数作为样本数据，尽管全体职工人数在统计上是很准确的，但其中有相当一部分与生产过程无关，不是模型所需要的。可比性，也就是通常所说的数据口径问题，在计量经济学模型研究中可以说无处不在。而人们容易得到的经济统计数据，一般可比性较差，其原因在于统计范围口径的变化和价格口径的变化，必须进行处理后才能用于模型参数的估计。计量经济学方法，是从样本数据中寻找经济活动本身客观存在的规律性，如果数据是不可比的，得到的规律性就难以反映实际。不同的研究者研究同一个经济现象，采用同样的变量和数学形式，选择的样本点也相同，但可能得到相差甚远的模型参数估计结果。为什么？原因在于样本数据的可比性。例如，采用时间序列数据作为生产函数模型的样本数据，产出量用不变价格计算的总产值，在不同年份间是可比的；资本用当年价格计算的固定资产原值，在不同年份间是不可比的。对于统计资料中直接提供的这个用当年价格计算的固定资产原值，有人直接用于模型估计，有人进行处理后再用于模型的估计，结果当然不会相同。一致性，即母体与样本的一致性。上面在讨论用截面数据作为计量经济学模型的样本数据时已经作了介绍。违反一致性的情况经常会发生，例如，用企业的数据作为行业生产函数模型的样本数据，用人均收入与消费的数据作为总量消费函数模型的样本数据，用31个省份的数据作为全国总量模型的样本数据，等等。三、模型参数的估计模型参数的估计方法，是计量经济学的核心内容。在建立了理论模型并收集整理了符合模型要求的样本数据之后，就可以选择适当的方法估计模型，得到模型参数的估计量。模型参数的估计是一个纯技术的过程，包括对模型进行识别（对联立方程模型而言）、估计方法的选择、软件的应用等内容。在后面的章节中将用大量的篇幅讨论估计问题，在此不重复叙述。四、模型的检验在模型的参数估计量已经得到后，可以说一个计量经济学模型已经初步建立起来了。但是，它能否客观揭示所研究的经济现象中诸因素之间的关系，能否付诸应用，还要通过检验才能决定。一般讲，计量经济学模型必须通过四级检验，即经济意义检验、统计学检验、计量经济学检验和预测检验。1.经济意义检验经济意义检验主要检验模型参数估计量在经济意义上的合理性。主要方法是将模型参数的估计量与预先拟定的理论期望值进行比较，包括参数估计量的符号、大小、相互之间的关系，以判断其合理性。首先检验参数估计量的符号。例如，有下列煤炭行业生产模型：煤炭产量＝-108.5427＋0.00067×固定资产原值＋0.01527×职工人数-0.00681×电力消耗量＋0.00256×木材消耗量在该模型中，电力消耗量前的参数估计量为负，意味着电力消耗越多，煤炭产量越低，从经济行为上无法解释。模型不能通过检验，应该找出原因重新建立模型。不管其他方面的质量多么高，模型也是没有实际价值的。2.统计检验统计检验是由统计理论决定的，目的在于检验模型的统计学性质。通常最广泛应用的统计检验准则有拟合优度检验、变量和方程的显著性检验等。3.计量经济学检验计量经济学检验是由计量经济学理论决定的，目的在于检验模型的计量经济学性质。通常最主要的检验准则有随机误差项的序列相关检验和异方差性检验，解释变量的多重共线性检验等。4.模型预测检验预测检验主要检验模型参数估计量的稳定性以及相对样本容量变化时的灵敏度，确定所建立的模型是否可以用于样本观测值以外的范围，即模型的所谓超样本特性。具体检验方法为：（1）利用扩大了的样本重新估计模型参数，将新的估计值与原来的估计值进行比较，并检验二者之间差距的显著性；（2）将所建立的模型用于样本以外某一时期的实际预测，并将该预测值与实际观测值进行比较，并检验二者之间差距的显著性。经历并通过了上述步骤的检验后，可以说已经建立了所需要的计量经济学模型，可以将它应用于预定的目的。五、计量经济学模型成功三要素从上述建立计量经济学模型的步骤中，不难看出，任何一项计量经济学研究、任何一个计量经济学模型赖以成功的要素应该有三个：理论、方法和数据。理论，即经济理论，所研究的经济现象的行为理论，是计量经济学研究的基础。方法，主要包括模型方法和计算方法，是计量经济学研究的工具与手段，是计量经济学不同于其他经济学分支学科的主要特征。数据，反映研究对象的活动水平、相互间联系以及外部环境的数据，或更广义讲是信息，是计量经济学研究的原料。这三方面缺一不可。一般情况下，在计量经济学研究中，方法的研究是人们关注的重点，方法的水平往往成为衡量一项研究成果水平的主要依据。这是正常的。计量经济学理论方法的研究是计量经济学研究工作者义不容辞的义务。但是，不能因此而忽视对经济学理论的探讨，一个不懂得经济学理论、不了解经济行为的人，是无法从事计量经济学研究工作的，是不可能建立起一个哪怕是极其简单的计量经济学模型的。所以，计量经济学家首先应该是一个经济学家。相比之下，人们对数据，尤其是数据质量问题的重视更显不足，在申请一项研究项目或评审一项研究成果时，对数据的可得性、可用性、可靠性缺乏认真的推敲；在研究过程中出现问题时，较少从数据质量方面去找原因。而目前的实际情况是，数据已经成为制约计量经济学发展的重要问题。六、相关分析、回归分析和因果分析从上述建立计量经济学模型的步骤中进一步看出，经典计量经济学方法的核心是采用回归分析的方法揭示变量之间的因果关系。但是，变量之间具有相关性并不等于具有因果性。这是建立计量经济学模型中一个十分重要的概念，那么首先需要对相关关系与因果关系作一简要的说明。所谓相关关系，是指两个以上的变量的样本观测值序列之间表现出来的随机数学关系，用相关系数来衡量。如果两个变量样本观测值序列之间相关系数的绝对值为1，则二者之间具有完全相关性（完全正相关或完全负相关）；如果相关系数的绝对值比较大，或接近于1，则二者之间具有较强相关性；如果相关系数的绝对值为0，或接近于0，则二者之间不具有相关性。如果一个变量与其他两个或两个以上变量的线性组合之间具有相关性，那么它与每一个变量之间的相关系数称为偏相关系数。相关关系是变量之间所表现出来的一种纯数学关系，判断变量之间是否具有相关关系的依据只有数据。所谓因果关系，是指两个或两个以上变量在行为机制上的依赖性，作为结果的变量是由作为原因的变量所决定的，原因变量的变化引起结果变量的变化。因果关系有单向因果关系和互为因果关系之分。例如，劳动力与国内生产总值之间具有单向因果关系，在经济行为上是劳动力影响国内生产总值，而不是相反；但是，在国内生产总值与消费总额之间则存在经济行为上的互为因果关系，国内生产总值既决定消费总额，反过来又受消费的拉动。具有因果关系的变量之间一定具有数学上的相关关系。而具有相关关系的变量之间并不一定具有因果关系。例如中国的国内生产总值与印度的人口之间具有较强的相关性，因为二者都以较快的速度增长，但显然二者之间不具有因果关系。相关分析是判断变量之间是否具有相关关系的数学分析方法，通过计算变量之间的相关系数来实现。回归分析也是判断变量之间是否具有相关关系的一种数学分析方法，它着重判断一个随机变量与一个或几个可控变量之间是否具有相关关系。由于它的特定的功能，所以也被用来进行变量之间的因果分析。但是，仅仅依靠回归分析尚不能对变量之间的因果关系作出最后判断，必须与经济行为的定性分析相结合。这就是上面强调的建立计量经济学模型的三要素。

对的

在回归分析模型 Y=β0+β1X+ε（一元线性回归模型）中，Y是被解释变量，就称为因变量。X是解释变量，称为自变量。表示为：因变量Y随自变量X的变化而变化。协变量是指那些人为很难控制的变量，通常在回归分析中要排除这些因素对结果的影响。“选择变量”即是条件变量，并且有个条件定义按钮（rule），通过这个按钮可以给定一个条件，只有变量值满足这个条件的样本数据才参与回归分析。做logistic 回归分析，用enter, foward, backword不同方法，结果为何不同?答：当前进法和后退法给出的答案相同，这是模型稳健的一种象征，但并不总是这样。前进法和后退法无需得到相同回答的理由是特定变量的重要性常常取决于变量选择时模型中有哪些其他的变量。某一变量当另一变量（或一组变量）处在模型中时是重要的，而当这一变量（或一组变量）不在模型中时，它却不显著了。这称为抑制效应。几种变量的选择技术的比较：1、 前进法：把变量逐次引入模型中。用已经在模型中的变量进行调整后的变量和结果变量间的相关程度决定引入的顺序（相关性最强的变量最先引入），最适于涉及样本含量小的研究。不能很好的解决抑制效应。2、 后退法：从模型中逐次剔除变量。用已经在模型中的变量进行调整后的变量和结果变量间的相关程度决定剔除的顺序（相关性最弱的变量最先剔除）。评价抑制效应比前进法好。3、 最优子集法：选择使某一特定参数达到最大的变量子集，但计算困难。4、 全变量法（全部变量）：同时引入所有的变量。如果自变量多、样本含量小或缺失数据多，把所有变量都包括进来可能会出问题。二分类 logistic回归中“变量选择方法”有7种，以下是spss手册中的介绍。Logistic 回归：变量选择方法：方法选择允许您指定自变量将如何进入到分析中。通过使用不同的方法，您可以从相同的变量组构造多个回归模型。- Enter.一种变量选择过程，其中一个块中的所有变量在一个步骤中输入。- 向前选择（条件）. 逐步选择方法，其中进入检验是基于得分统计量的显著性，移去检验是基于在条件参数估计基础上的似然比统计的概率。- 向前选择（似然比）. 逐步选择方法，其中进入检验是基于得分统计量的显著性，移去检验是基于在最大局部似然估计的似然比统计的概率。- 向前选择 (Wald). 逐步选择方法，其中进入检验是基于得分统计量的显著性，移去检验是基于 Wald 统计的概率。- 向后去除（条件）. 逐步向后选择。移去检验基于在条件参数估计的似然比统计量的概率。- 向后去除（似然比）. 逐步向后选择。移去检验基于在最大偏似然估计基础上的似然比统计量的概率。- 向后去除（Wald）. 逐步向后选择。移去检验基于 Wald 统计量的概率。一般来说，backward更准确一些，后退法优于前进。但是变量太多，会很慢。stepwise用的最广泛，但也有人说慎用逐步回归的方法。总之，选哪种都行，选择拟合最好的就可以了。大致来说，就是决定系数R2最大的就是。

LinkBlockQueue是一种线程安全的队列数据结构，它可以实现多线程之间的数据共享。它的实现不需要创建新线程，因为它是基于现有线程的同步机制实现的。它使用了锁和条件变量来实现线程之间的同步和通信。当一个线程需要向队列中添加元素时，它会先获取锁，然后判断队列是否已满，如果已满则等待条件变量，直到有其他线程取走了元素，才会将元素添加到队列中，并通知其他线程。当一个线程需要从队列中取出元素时，它也会先获取锁，然后判断队列是否为空，如果为空则等待条件变量，直到有其他线程添加了元素，才会取出元素，并通知其他线程。这样，所有的线程都可以安全地访问和修改队列，而不会引起竞争条件和死锁问题。

协变量和自变量的区别：在一个回归模型中，“自变量”就是所谓的“解释变量”。比如研究收入和受教育年限的回归模型中，收入是因变量，受教育年限是自变量或者说解释变量（解释因变量变化的原因，所以叫它解释变量）。协变量呢？协变量其实也会影响“因变量”，但是他并不是你想研究的对象，对如说年龄这个变量，你想研究的收入和受教育年限的关系，但是很明显，年龄也会影响收入，所以它是你希望控制住的变量，也就是我们要在同一个年龄层次上研究收入和受教育年限的关系以排除年龄因素的干扰，这样的控制变量就是协变量。其实如果你喜欢，你完全可以把协变量也作为自变量，但是注意，之所以你没有把它作为自变量放入回归模型，因为你不关心它和因变量的关系而已。

Linux 线程同步的三种方法线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。一、互斥锁(mutex)通过锁机制实现线程间的同步。初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。int pthread_mutex_lock(pthread_mutex *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。int pthread_mutex_unlock(pthread_mutex_t *mutex);销毁锁。锁在是使用完成后，需要进行销毁以释放资源。int pthread_mutex_destroy(pthread_mutex *mutex);[csharp] view plain copy#include <cstdio>#include <cstdlib>#include <unistd.h>#include <pthread.h>#include "iostream"using namespace std;pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;int tmp;void* thread(void *arg){cout << "thread id is " << pthread_self() << endl;pthread_mutex_lock(&mutex);tmp = 12;cout << "Now a is " << tmp << endl;pthread_mutex_unlock(&mutex);return NULL;}int main(){pthread_t id;cout << "main thread id is " << pthread_self() << endl;tmp = 3;cout << "In main func tmp = " << tmp << endl;if (!pthread_create(&id, NULL, thread, NULL)){cout << "Create thread success!" << endl;}else{cout << "Create thread failed!" << endl;}pthread_join(id, NULL);pthread_mutex_destroy(&mutex);return 0;}//编译：g++ -o thread testthread.cpp -lpthread二、条件变量(cond)互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分: 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。初始化条件变量。静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER;动态初始化，int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);等待条件成立。释放锁,同时阻塞等待条件变量为真才行。timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);激活条件变量。pthread_cond_signal,pthread_cond_broadcast（激活所有等待线程）int pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有线程的阻塞清除条件变量。无线程等待,否则返回EBUSYint pthread_cond_destroy(pthread_cond_t *cond);[cpp] view plain copy#include <stdio.h>#include <pthread.h>#include "stdlib.h"#include "unistd.h"pthread_mutex_t mutex;pthread_cond_t cond;void hander(void *arg){free(arg);(void)pthread_mutex_unlock(&mutex);}void *thread1(void *arg){pthread_cleanup_push(hander, &mutex);while(1){printf("thread1 is running ");pthread_mutex_lock(&mutex);pthread_cond_wait(&cond, &mutex);printf("thread1 applied the condition ");pthread_mutex_unlock(&mutex);sleep(4);}pthread_cleanup_pop(0);}void *thread2(void *arg){while(1){printf("thread2 is running ");pthread_mutex_lock(&mutex);pthread_cond_wait(&cond, &mutex);printf("thread2 applied the condition ");pthread_mutex_unlock(&mutex);sleep(1);}}int main(){pthread_t thid1,thid2;printf("condition variable study! ");pthread_mutex_init(&mutex, NULL);pthread_cond_init(&cond, NULL);pthread_create(&thid1, NULL, thread1, NULL);pthread_create(&thid2, NULL, thread2, NULL);sleep(1);do{pthread_cond_signal(&cond);}while(1);sleep(20);pthread_exit(0);return 0;}[cpp] view plain copy#include <pthread.h>#include <unistd.h>#include "stdio.h"#include "stdlib.h"static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;struct node{int n_number;struct node *n_next;}*head = NULL;static void cleanup_handler(void *arg){printf("Cleanup handler of second thread./n");free(arg);(void)pthread_mutex_unlock(&mtx);}static void *thread_func(void *arg){struct node *p = NULL;pthread_cleanup_push(cleanup_handler, p);while (1){//这个mutex主要是用来保证pthread_cond_wait的并发性pthread_mutex_lock(&mtx);while (head == NULL){//这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何//这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线//程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。//这个时候，应该让线程继续进入pthread_cond_wait// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，//然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立//而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源//用这个流程是比较清楚的pthread_cond_wait(&cond, &mtx);p = head;head = head->n_next;printf("Got %d from front of queue/n", p->n_number);free(p);}pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁}pthread_cleanup_pop(0);return 0;}int main(void){pthread_t tid;int i;struct node *p;//子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而//不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大pthread_create(&tid, NULL, thread_func, NULL);sleep(1);for (i = 0; i < 10; i++){p = (struct node*)malloc(sizeof(struct node));p->n_number = i;pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁，p->n_next = head;head = p;pthread_cond_signal(&cond);pthread_mutex_unlock(&mtx); //解锁sleep(1);}printf("thread 1 wanna end the line.So cancel thread 2./n");//关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出//线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。pthread_cancel(tid);pthread_join(tid, NULL);printf("All done -- exiting/n");return 0;}三、信号量(sem)如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。信号量初始化。int sem_init (sem_t *sem , int pshared, unsigned int value);这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。等待信号量。给信号量减1，然后等待直到信号量的值大于0。int sem_wait(sem_t *sem);释放信号量。信号量值加1。并通知其他等待线程。int sem_post(sem_t *sem);销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。int sem_destroy(sem_t *sem);[cpp] view plain copy#include <stdlib.h>#include <stdio.h>#include <unistd.h>#include <pthread.h>#include <semaphore.h>#include <errno.h>#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}typedef struct _PrivInfo{sem_t s1;sem_t s2;time_t end_time;}PrivInfo;static void info_init (PrivInfo* thiz);static void info_destroy (PrivInfo* thiz);static void* pthread_func_1 (PrivInfo* thiz);static void* pthread_func_2 (PrivInfo* thiz);int main (int argc, char** argv){pthread_t pt_1 = 0;pthread_t pt_2 = 0;int ret = 0;PrivInfo* thiz = NULL;thiz = (PrivInfo* )malloc (sizeof (PrivInfo));if (thiz == NULL){printf ("[%s]: Failed to malloc priv./n");return -1;}info_init (thiz);ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);if (ret != 0){perror ("pthread_1_create:");}ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);if (ret != 0){perror ("pthread_2_create:");}pthread_join (pt_1, NULL);pthread_join (pt_2, NULL);info_destroy (thiz);return 0;}static void info_init (PrivInfo* thiz){return_if_fail (thiz != NULL);thiz->end_time = time(NULL) + 10;sem_init (&thiz->s1, 0, 1);sem_init (&thiz->s2, 0, 0);return;}static void info_destroy (PrivInfo* thiz){return_if_fail (thiz != NULL);sem_destroy (&thiz->s1);sem_destroy (&thiz->s2);free (thiz);thiz = NULL;return;}static void* pthread_func_1 (PrivInfo* thiz){return_if_fail(thiz != NULL);while (time(NULL) < thiz->end_time){sem_wait (&thiz->s2);printf ("pthread1: pthread1 get the lock./n");sem_post (&thiz->s1);printf ("pthread1: pthread1 unlock/n");sleep (1);}return;}static void* pthread_func_2 (PrivInfo* thiz){return_if_fail (thiz != NULL);while (time (NULL) < thiz->end_time){sem_wait (&thiz->s1);printf ("pthread2: pthread2 get the unlock./n");sem_post (&thiz->s2);printf ("pthread2: pthread2 unlock./n");sleep (1);}return;}

通过条件变量控制线程的执行，线程内部检查变量状态，外部改变变量值可控制停止执行。为保证线程间的即时通信，需要使用使用volatile关键字或锁，确保读线程与写线程间变量状态一致。下面给一个最佳模板：/*** @author bruce_sha (bruce-sha.github.io)* @version*/public class BestPractice extends Thread {private volatile boolean finished = false; // ① volatile条件变量public void stopMe() {finished = true; // ② 发出停止信号}@Overridepublic void run() {while (!finished) { // ③ 检测条件变量// do dirty work // ④业务代码}}}

猴子阿吉想了想爬上树中央左手右手动了动

　　信号量强调的是线程（或进程）间的同步：“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都 在sem_wait的时候，就阻塞在那里）。当信号量为单值信号量是，也可以完成一个资源的互斥访问。　　　　有名信号量：可以用于不同进程间或多线程间的互斥与同步　　创建打开有名信号量　　sem_t *sem_open(const char *name, int oflag);　　sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);　　　　成功返回信号量指针；失败返回SEM_FAILED，设置errnoname是文件路径名,但不能写成/tmp/a.sem这样的形式,因为在linux下,sem都是在/dev/shm目录下,可写成"/mysem"或"mysem",创建出来的文件都 是"/dev/shm/sem.mysem",mode设置为0666，value设置为信号量的初始值.所需信号灯等已存在条件下指定O_CREAT|O_EXCL却是个错误。　　　　关闭信号量，进程终止时，会自动调用它　　int sem_close(sem_t *sem);　　成功返回0；失败返回-1，设置errno　　　　删除信号量，立即删除信号量名字，当其他进程都关闭它时，销毁它　　int sem_unlink(const char *name);　　　　等待信号量，测试信号量的值，如果其值小于或等于0，那么就等待（阻塞）；一旦其值变为大于0就将它减1，并返回　　int sem_wait(sem_t *sem);　　int sem_trywait(sem_t *sem);　　　　成功返回0；失败返回-1，设置errno　　　　当信号量的值为0时，sem_trywait立即返回，设置errno为EAGAIN。如果被某个信号中断，sem_wait会过早地返回，设置errno为EINTR　　　　发出信号量，给它的值加1，然后唤醒正在等待该信号量的进程或线程　　int sem_post(sem_t *sem);　　　　成功返回0；失败返回-1，不会改变它的值，设置errno，该函数是异步信号安全的，可以在信号处理程序里调用它无名信号量，用于进程体内各线程间的互斥和同步,使用如下API(无名信号量,基于内存的信号量)　　　　（1）、sem_init　　　　功能：用于创建一个信号量，并初始化信号量的值。　　　　头文件：　　　　函数原型： int sem_init (sem_t* sem, int pshared, unsigned int value);　　　　函数传入值： sem:信号量。pshared:决定信号量能否在几个进程间共享。由于目前LINUX还没有实现进程间共享信息量，所以这个值只能取0。　　　　（2）其他函数。　　int sem_wait (sem_t* sem);　　int sem_trywait (sem_t* sem);　　int sem_post (sem_t* sem);　　int sem_getvalue (sem_t* sem);　　int sem_destroy (sem_t* sem);　　　　功能：sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。sem_post相当于V操作，它将信号量的值加一，同时发出唤醒的信号给等待的进程（或线程）。　　　　sem_getvalue 得到信号量的值。　　　　sem_destroy 摧毁信号量。　　　　如果某个基于内存的信号灯是在不同进程间同步的，该信号灯必须存放在共享内存区中，这要只要该共享内存区存在，该信号灯就存在。　　　　互斥锁(又名互斥量）强调的是资源的访问互斥：互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的”　　　　也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。在有些情况下两者可以互换。　　　　在linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:　　　　对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.　　　　对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.　　原型:　　int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);　　int pthread_mutex_destroy(pthread_mutex_t *mutex);　　　　头文件:　　　　返回值: 成功则返回0, 出错则返回错误编号.　　　　说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.　　　　首先说一下加锁函数:　　　　头文件:　　int pthread_mutex_lock(pthread_mutex_t *mutex);　　int pthread_mutex_trylock(pthread_mutex_t *mutex);　　　　返回值: 成功则返回0, 出错则返回错误编号.　　　　说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量 被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.　　　　再说一下解所函数:　　　　头文件:　　原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);　　　　返回值: 成功则返回0, 出错则返回错误编号.　　　　条件变量常与互斥锁同时使用，达到线程同步的目的：条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足。在发 送信号时，如果没有线程 等待在该条件变量上，那么信号将丢失；而信号量有计数值，每次信号量post操作都会被记录　　　　1. 互斥锁必须是谁上锁就由谁来解锁，而信号量的wait和post操作不必由同一个线程执行。　　　　2. 互斥锁要么被锁住，要么被解开，和二值信号量类似　　　　3. sem_post是各种同步技巧中，唯一一个能在信号处理程序中安全调用的函数　　　　4. 互斥锁是为上锁而优化的；条件变量是为等待而优化的； 信号量既可用于上锁，也可用于等待，因此会有更多的开销和更高的复杂性　　　　5. 互斥锁，条件变量都只用于同一个进程的各线程间，而信号量（有名信号量）可用于不同进程间的同步。当信号量用于进程间同步时，要求信号量建立在共享内存区。　　　　6. 信号量有计数值，每次信号量post操作都会被记录，而条件变量在发送信号时，如果没有线程在等待该条件变量，那么信号将丢失。　　　　读写锁　　　　读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。　　　　读写锁可以由三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写　　锁。　　　　在读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。虽然读写锁的实现各不相同，但当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。　　　　读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为当前只有一个线程可以在写模式下拥 有这个锁。当读写锁在读状态下时，只要线程获取了读模式下的读写锁，该锁所保护的数据结构可以被多个获得读模式锁的线程读取。　　　　读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的；当他以写模式锁住时，它是以独占模式锁住的。　　初始化和销毁:　　#include　　int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);　　int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);　　　　成功则返回0, 出错则返回错误编号.　　　　同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过thread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.　　　　读和写:　　#include　　int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);　　int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);　　int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);　　　　成功则返回0, 出错则返回错误编号.　　　　这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:　　#include　　int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);　　int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);　　　　成功则返回0, 出错则返回错误编号.　　　　非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.　　　　虽然读写锁提高了并行性，但是就速度而言并不比互斥量快.　　　　可能这也是即使有读写锁存在还会使用互斥量的原因，因为他在速度方面略胜一筹。这就需要我们在写程序的时候综合考虑速度和并行性并找到一个折中。　　　　比如： 假设使用互斥量需要0.5秒，使用读写锁需要0.8秒。在类似学生管理系统这类软件中，可能百分之九十的时间都是查询操作，那么假如现在突然来个个20个请求，如果使用的是互斥量，那么最后的那个查询请求被满足需要10后。这样，估计没人能受得了。而使用读写锁，应为 读锁能够多次获得。所以所有的20个请求，每个请求都能在1秒左右得到满足。　　　　也就是说，在一些写操作比较多或是本身需要同步的地方并不多的程序中我们应该使用互斥量，而在读操作远大于写操作的一些程序中我们应该使用读写锁来进行同步　　　　条件变量(condition)　　　　条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。　　　　条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其它线程在获得互斥量之前不会察觉到这种改变，因此必须锁定互斥量以后才能计算条件。　　　　条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件　　　　变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。　　　　1. 初始化:　　　　条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:　　　　静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.　　动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.　　#include　　int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);　　int pthread_cond_destroy(pthread_cond_t *cond);　　　　成功则返回0, 出错则返回错误编号.　　　　注意：条件变量占用的空间并未被释放。　　　　当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.　　　　2. 等待条件:　　#include　　int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);　　int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);　　　　成功则返回0, 出错则返回错误编号.　　　　这两个函数分别是阻塞等待和超时等待.　　　　等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样 便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.　　　　当pthread_cond_wait返回时, 互斥量再次被锁住.　　　　pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。　　　　pthread_cond_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。　　　　阻塞在条件变量上的线程被唤醒以后，直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条 件值。最好的测试方法是循环调用pthread_cond_wait函数，并把满足条件的表达式置为循环的终止条件。如：　　　　pthread_mutex_lock();　　　　while (condition_is_false)　　　　pthread_cond_wait();　　　　pthread_mutex_unlock();　　　　阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。　　　　注意：pthread_cond_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条 件变量相关的互斥锁仍将处在锁定状态。　　　　pthread_cond_timedwait函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。　　　　注意：pthread_cond_timedwait函数也是退出点。　　　　超时时间参数是指一天中的某个时刻。使用举例：　　　　pthread_timestruc_t to;　　　　to.tv_sec = time(NULL) + TIMEOUT;　　　　to.tv_nsec = 0;　　　　超时返回的错误码是ETIMEDOUT。　　　　3. 通知条件:　　#include　　int pthread_cond_signal(pthread_cond_t *cond);　　int pthread_cond_broadcast(pthread_cond_t *cond);　　　　成功则返回0, 出错则返回错误编号.　　　　这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

公式前面都没问题，到10这个以后就抓取出错了，是公式哪里问题吗？我自己重新更改好了，请各位朋友参考=IF(A1=1,50,IF(A1=2,100,IF(A1=3,150,IF(A1=4,200,IF(A1=5,250,IF(A1=6,300,IF(A1=7,350,IF(A1=8,400,IF(A1=9,450,IF(A1≥10,500))))))))))

你不管他是条件变量还是其他什么变量。只要理解，因为这个变量/资源是共享的，可能会有多个进程或线程去修改它，那么就必须为它添加一个锁，这个锁是每次只有一个进程/线程可以获取到的。打个比方，mutex是一个布尔型变量，表示这个资源变量（锁）的一个钥匙。为真的是时候表示这个钥匙当前是可以借，反之为假的时候表示已经有线程在使用这个钥匙。在Java里边就用关键字synchronized来指定一个代码块一次只有一个线程可以访问。取钥匙这个函数/方法的算法就可以这么理解了：如果这个锁可借，那么返回真，表示可借；否则返回假表示不可借publicsynchronizedbooleangetmutex(){//取钥匙if(mutex==true)//钥匙空闲可用{mutex=false;//取钥匙就进行修改，证明这一次取钥匙已经发生returntrue;//返回真，表示取钥匙成功}elsereturnfalse;//这个钥匙正在被使用，返回假表示去钥匙失败}就像一个公用电话亭，这就相当于规定了一次只允许一个人进门，你进去了就把门关上。门关着其他人就进不去了，只有你打完电话出来开门，释放这个锁，其他人才可以进去。通过synchronized关键字将取钥匙跟进门两个动作放在在一起，绑在一块。其中门就是条件变量，mutex就是这个门的互斥锁。

为了能够有效的控制多个进程之间的沟通过程，保证沟通过程的有序和和谐，OS必须提供一定的同步机制保证进程之间不会自说自话而是有效的协同工作。比如在 共享内存的通信方式中，两个或者多个进程都要对共享的内存进行数据写入，那么怎么才能保证一个进程在写入的过程中不被其它的进程打断，保证数据的完整性 呢？又怎么保证读取进程在读取数据的过程中数据不会变动，保证读取出的数据是完整有效的呢？ 常用的同步方式有： 互斥锁、条件变量、读写锁、记录锁(文件锁)和信号灯. 互斥锁： 顾名思义，锁是用来锁住某种东西的，锁住之后只有有钥匙的人才能对锁住的东西拥有控制权(把锁砸了，把东西偷走的小偷不在我们的讨论范围了)。所谓互斥， 从字面上理解就是互相排斥。因此互斥锁从字面上理解就是一点进程拥有了这个锁，它将排斥其它所有的进程访问被锁住的东西，其它的进程如果需要锁就只能等待，等待拥有锁的进程把锁打开后才能继续运行。 在实现中，锁并不是与某个具体的变量进行关联，它本身是一个独立的对象。进(线)程在有需要的时候获得此对象，用完不需要时就释放掉。 互斥锁的主要特点是互斥锁的释放必须由上锁的进(线)程释放，如果拥有锁的进(线)程不释放，那么其它的进(线)程永远也没有机会获得所需要的互斥锁。 互斥锁主要用于线程之间的同步。 条件变量： 上文中提到，对于互斥锁而言，如果拥有锁的进(线)程不释放锁，其它进(线)程永远没机会获得锁，也就永远没有机会继续执行后续的逻辑。在实际环境下，一 个线程A需要改变一个共享变量X的值，为了保证在修改的过程中X不会被其它的线程修改，线程A必须首先获得对X的锁。现在假如A已经获得锁了，由于业务逻 辑的需要，只有当X的值小于0时，线程A才能执行后续的逻辑，于是线程A必须把互斥锁释放掉，然后继续“忙等”。如下面的伪代码所示： 1.// get x lock 2.while(x

条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待条件变量的条件成立而挂起；另一个线程使条件成立（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。

信号量强调的是线程（或进程）间的同步：“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都 在sem_wait的时候，就阻塞在那里）。当信号量为单值信号量是，也可以完成一个资源的互斥访问。有名信号量：可以用于不同进程间或多线程间的互斥与同步创建打开有名信号量sem_t *sem_open(const char *name, int oflag);sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);成功返回信号量指针；失败返回SEM_FAILED，设置errnoname是文件路径名,但不能写成/tmp/a.sem这样的形式,因为在linux下,sem都是在/dev/shm目录下,可写成"/mysem"或"mysem",创建出来的文件都 是"/dev/shm/sem.mysem",mode设置为0666，value设置为信号量的初始值.所需信号灯等已存在条件下指定O_CREAT|O_EXCL却是个错误。关闭信号量，进程终止时，会自动调用它int sem_close(sem_t *sem);成功返回0；失败返回-1，设置errno删除信号量，立即删除信号量名字，当其他进程都关闭它时，销毁它int sem_unlink(const char *name);等待信号量，测试信号量的值，如果其值小于或等于0，那么就等待（阻塞）；一旦其值变为大于0就将它减1，并返回int sem_wait(sem_t *sem);int sem_trywait(sem_t *sem);成功返回0；失败返回-1，设置errno当信号量的值为0时，sem_trywait立即返回，设置errno为EAGAIN。如果被某个信号中断，sem_wait会过早地返回，设置errno为EINTR发出信号量，给它的值加1，然后唤醒正在等待该信号量的进程或线程int sem_post(sem_t *sem);成功返回0；失败返回-1，不会改变它的值，设置errno，该函数是异步信号安全的，可以在信号处理程序里调用它无名信号量，用于进程体内各线程间的互斥和同步,使用如下API(无名信号量,基于内存的信号量)（1）、sem_init功能：用于创建一个信号量，并初始化信号量的值。头文件：函数原型： int sem_init (sem_t* sem, int pshared, unsigned int value);函数传入值： sem:信号量。pshared:决定信号量能否在几个进程间共享。由于目前LINUX还没有实现进程间共享信息量，所以这个值只能取0。（2）其他函数。int sem_wait (sem_t* sem);int sem_trywait (sem_t* sem);int sem_post (sem_t* sem);int sem_getvalue (sem_t* sem);int sem_destroy (sem_t* sem);功能：sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。sem_post相当于V操作，它将信号量的值加一，同时发出唤醒的信号给等待的进程（或线程）。sem_getvalue 得到信号量的值。sem_destroy 摧毁信号量。如果某个基于内存的信号灯是在不同进程间同步的，该信号灯必须存放在共享内存区中，这要只要该共享内存区存在，该信号灯就存在。互斥锁(又名互斥量）强调的是资源的访问互斥：互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的”也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。在有些情况下两者可以互换。在linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.原型:int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);int pthread_mutex_destroy(pthread_mutex_t *mutex);头文件:返回值: 成功则返回0, 出错则返回错误编号.说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.首先说一下加锁函数:头文件:int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);返回值: 成功则返回0, 出错则返回错误编号.说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量 被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.再说一下解所函数:头文件:原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);返回值: 成功则返回0, 出错则返回错误编号.条件变量常与互斥锁同时使用，达到线程同步的目的：条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足。在发 送信号时，如果没有线程 等待在该条件变量上，那么信号将丢失；而信号量有计数值，每次信号量post操作都会被记录互斥锁必须是谁上锁就由谁来解锁，而信号量的wait和post操作不必由同一个线程执行。2. 互斥锁要么被锁住，要么被解开，和二值信号量类似3. sem_post是各种同步技巧中，唯一一个能在信号处理程序中安全调用的函数4. 互斥锁是为上锁而优化的；条件变量是为等待而优化的； 信号量既可用于上锁，也可用于等待，因此会有更多的开销和更高的复杂性5. 互斥锁，条件变量都只用于同一个进程的各线程间，而信号量（有名信号量）可用于不同进程间的同步。当信号量用于进程间同步时，要求信号量建立在共享内存区。6. 信号量有计数值，每次信号量post操作都会被记录，而条件变量在发送信号时，如果没有线程在等待该条件变量，那么信号将丢失。读写锁读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以由三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。在读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。虽然读写锁的实现各不相同，但当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为当前只有一个线程可以在写模式下拥 有这个锁。当读写锁在读状态下时，只要线程获取了读模式下的读写锁，该锁所保护的数据结构可以被多个获得读模式锁的线程读取。读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的；当他以写模式锁住时，它是以独占模式锁住的。初始化和销毁:#includeint pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过thread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.读和写:#includeint pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:#includeint pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.虽然读写锁提高了并行性，但是就速度而言并不比互斥量快.可能这也是即使有读写锁存在还会使用互斥量的原因，因为他在速度方面略胜一筹。这就需要我们在写程序的时候综合考虑速度和并行性并找到一个折中。比如： 假设使用互斥量需要0.5秒，使用读写锁需要0.8秒。在类似学生管理系统这类软件中，可能百分之九十的时间都是查询操作，那么假如现在突然来个个20个请求，如果使用的是互斥量，那么最后的那个查询请求被满足需要10后。这样，估计没人能受得了。而使用读写锁，应为 读锁能够多次获得。所以所有的20个请求，每个请求都能在1秒左右得到满足。也就是说，在一些写操作比较多或是本身需要同步的地方并不多的程序中我们应该使用互斥量，而在读操作远大于写操作的一些程序中我们应该使用读写锁来进行同步条件变量(condition)条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其它线程在获得互斥量之前不会察觉到这种改变，因此必须锁定互斥量以后才能计算条件。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。初始化:条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.#includeint pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond);成功则返回0, 出错则返回错误编号.注意：条件变量占用的空间并未被释放。当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.2. 等待条件:#includeint pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);成功则返回0, 出错则返回错误编号.这两个函数分别是阻塞等待和超时等待.等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样 便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.当pthread_cond_wait返回时, 互斥量再次被锁住.pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。pthread_cond_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。阻塞在条件变量上的线程被唤醒以后，直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条 件值。最好的测试方法是循环调用pthread_cond_wait函数，并把满足条件的表达式置为循环的终止条件。如：pthread_mutex_lock();while (condition_is_false)pthread_cond_wait();pthread_mutex_unlock();阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。注意：pthread_cond_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条 件变量相关的互斥锁仍将处在锁定状态。pthread_cond_timedwait函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。注意：pthread_cond_timedwait函数也是退出点。超时时间参数是指一天中的某个时刻。使用举例：pthread_timestruc_t to;to.tv_sec = time(NULL) + TIMEOUT;to.tv_nsec = 0;超时返回的错误码是ETIMEDOUT。3. 通知条件:#includeint pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond);成功则返回0, 出错则返回错误编号.这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

在回归分析模型 Y=β0+β1X+ε（一元线性回归模型）中，Y是被解释变量，就称为因变量。X是解释变量，称为自变量。表示为：因变量Y随自变量X的变化而变化。协变量是指那些人为很难控制的变量，通常在回归分析中要排除这些因素对结果的影响。“选择变量”即是条件变量，并且有个条件定义按钮（rule），通过这个按钮可以给定一个条件，只有变量值满足这个条件的样本数据才参与回归分析。希望能帮到你！

信号量强调的是线程（或进程）间的同步：“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都 在sem_wait的时候，就阻塞在那里）。当信号量为单值信号量是，也可以完成一个资源的互斥访问。有名信号量：可以用于不同进程间或多线程间的互斥与同步创建打开有名信号量sem_t *sem_open(const char *name, int oflag);sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);成功返回信号量指针；失败返回SEM_FAILED，设置errnoname是文件路径名,但不能写成/tmp/a.sem这样的形式,因为在linux下,sem都是在/dev/shm目录下,可写成"/mysem"或"mysem",创建出来的文件都 是"/dev/shm/sem.mysem",mode设置为0666，value设置为信号量的初始值.所需信号灯等已存在条件下指定O_CREAT|O_EXCL却是个错误。关闭信号量，进程终止时，会自动调用它int sem_close(sem_t *sem);成功返回0；失败返回-1，设置errno删除信号量，立即删除信号量名字，当其他进程都关闭它时，销毁它int sem_unlink(const char *name);等待信号量，测试信号量的值，如果其值小于或等于0，那么就等待（阻塞）；一旦其值变为大于0就将它减1，并返回int sem_wait(sem_t *sem);int sem_trywait(sem_t *sem);成功返回0；失败返回-1，设置errno当信号量的值为0时，sem_trywait立即返回，设置errno为EAGAIN。如果被某个信号中断，sem_wait会过早地返回，设置errno为EINTR发出信号量，给它的值加1，然后唤醒正在等待该信号量的进程或线程int sem_post(sem_t *sem);成功返回0；失败返回-1，不会改变它的值，设置errno，该函数是异步信号安全的，可以在信号处理程序里调用它无名信号量，用于进程体内各线程间的互斥和同步,使用如下API(无名信号量,基于内存的信号量)（1）、sem_init功能：用于创建一个信号量，并初始化信号量的值。头文件：函数原型： int sem_init (sem_t* sem, int pshared, unsigned int value);函数传入值： sem:信号量。pshared:决定信号量能否在几个进程间共享。由于目前LINUX还没有实现进程间共享信息量，所以这个值只能取0。（2）其他函数。int sem_wait (sem_t* sem);int sem_trywait (sem_t* sem);int sem_post (sem_t* sem);int sem_getvalue (sem_t* sem);int sem_destroy (sem_t* sem);功能：sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。sem_post相当于V操作，它将信号量的值加一，同时发出唤醒的信号给等待的进程（或线程）。sem_getvalue 得到信号量的值。sem_destroy 摧毁信号量。如果某个基于内存的信号灯是在不同进程间同步的，该信号灯必须存放在共享内存区中，这要只要该共享内存区存在，该信号灯就存在。互斥锁(又名互斥量）强调的是资源的访问互斥：互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的”也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。在有些情况下两者可以互换。在linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.原型:int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);int pthread_mutex_destroy(pthread_mutex_t *mutex);头文件:返回值: 成功则返回0, 出错则返回错误编号.说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.首先说一下加锁函数:头文件:int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);返回值: 成功则返回0, 出错则返回错误编号.说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量 被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.再说一下解所函数:头文件:原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);返回值: 成功则返回0, 出错则返回错误编号.条件变量常与互斥锁同时使用，达到线程同步的目的：条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足。在发 送信号时，如果没有线程 等待在该条件变量上，那么信号将丢失；而信号量有计数值，每次信号量post操作都会被记录互斥锁必须是谁上锁就由谁来解锁，而信号量的wait和post操作不必由同一个线程执行。2. 互斥锁要么被锁住，要么被解开，和二值信号量类似3. sem_post是各种同步技巧中，唯一一个能在信号处理程序中安全调用的函数4. 互斥锁是为上锁而优化的；条件变量是为等待而优化的； 信号量既可用于上锁，也可用于等待，因此会有更多的开销和更高的复杂性5. 互斥锁，条件变量都只用于同一个进程的各线程间，而信号量（有名信号量）可用于不同进程间的同步。当信号量用于进程间同步时，要求信号量建立在共享内存区。6. 信号量有计数值，每次信号量post操作都会被记录，而条件变量在发送信号时，如果没有线程在等待该条件变量，那么信号将丢失。读写锁读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以由三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。在读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。虽然读写锁的实现各不相同，但当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为当前只有一个线程可以在写模式下拥 有这个锁。当读写锁在读状态下时，只要线程获取了读模式下的读写锁，该锁所保护的数据结构可以被多个获得读模式锁的线程读取。读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的；当他以写模式锁住时，它是以独占模式锁住的。初始化和销毁:#includeint pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过thread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.读和写:#includeint pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:#includeint pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.虽然读写锁提高了并行性，但是就速度而言并不比互斥量快.可能这也是即使有读写锁存在还会使用互斥量的原因，因为他在速度方面略胜一筹。这就需要我们在写程序的时候综合考虑速度和并行性并找到一个折中。比如： 假设使用互斥量需要0.5秒，使用读写锁需要0.8秒。在类似学生管理系统这类中，可能百分之九十的时间都是查询操作，那么假如现在突然来个个20个请求，如果使用的是互斥量，那么最后的那个查询请求被满足需要10后。这样，估计没人能受得了。而使用读写锁，应为 读锁能够多次获得。所以所有的20个请求，每个请求都能在1秒左右得到满足。也就是说，在一些写操作比较多或是本身需要同步的地方并不多的程序中我们应该使用互斥量，而在读操作远大于写操作的一些程序中我们应该使用读写锁来进行同步条件变量(condition)条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其它线程在获得互斥量之前不会察觉到这种改变，因此必须锁定互斥量以后才能计算条件。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。1. 初始化:条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.#includeint pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond);成功则返回0, 出错则返回错误编号.注意：条件变量占用的空间并未被释放。当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.2. 等待条件:#includeint pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);成功则返回0, 出错则返回错误编号.这两个函数分别是阻塞等待和超时等待.等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样 便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.当pthread_cond_wait返回时, 互斥量再次被锁住.pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。pthread_cond_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。阻塞在条件变量上的线程被唤醒以后，直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条 件值。最好的测试方法是循环调用pthread_cond_wait函数，并把满足条件的表达式置为循环的终止条件。如：pthread_mutex_lock();while (condition_is_false)pthread_cond_wait();pthread_mutex_unlock();阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。注意：pthread_cond_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条 件变量相关的互斥锁仍将处在锁定状态。pthread_cond_timedwait函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。注意：pthread_cond_timedwait函数也是退出点。超时时间参数是指一天中的某个时刻。使用举例：pthread_timestruc_t to;to.tv_sec = time(NULL) + TIMEOUT;to.tv_nsec = 0;超时返回的错误码是ETIMEDOUT。3. 通知条件:#includeint pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond);成功则返回0, 出错则返回错误编号.这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

spss中的多元logistic回归中的协变量定义：在实验的设计中，协变量是一个独立变量（解释变量），不为实验者所操纵，但仍影响实验结果。协变量是指那些人为很难控制的变量，通常在回归分析中要排除这些因素对结果的影响。“选择变量”即是条件变量，并且有个条件定义按钮（rule），通过这个按钮可以给定一个条件，只有变量值满足这个条件的样本数据才参与回归分析。协变量（covariate）在心理学、行为科学中，是指与因变量有线性相关并在探讨自变量与因变量关系时通过统计技术加以控制的变量。

命题错误的是C项.

在回归分析模型Y=β0+β1X+ε（一元线性回归模型）中，Y是被解释变量，就称为因变量。X是解释变量，称为自变量。表示为：因变量Y随自变量X的变化而变化。协变量是指那些人为很难控制的变量，通常在回归分析中要排除这些因素对结果的影响。“选择变量”即是条件变量，并且有个条件定义按钮（rule），通过这个按钮可以给定一个条件，只有变量值满足这个条件的样本数据才参与回归分析。希望能帮到你！

计量经济学中参数的标准差按下式确定：S.E. of regression=[Sum of Squared Residuals/(T-k)]^(1/2)Sum of Squared Residuals是表中数据，T是观测数，k是变量数，包括常数项。

服务器在调用listen和accept后，就会阻塞在accept函数上，accpet函数返回后循环调用accept函数等待客户的TCP连接。如果这时候又大量的用户并发发起connect连接，那么在listen有队列上限(最大可接受TCP的连接数)的情况下，有多少个connect会成功了。试验证明，当连接数远远高于listen的可连接数上限时，客户端的大部分TCP请求会被抛弃，只有当listen监听队列空闲或者放弃某个连接时，才可以接收新的连接，那么我们应该如何来避免这种情况出现？分析：（一）客户端客户端运行初期完成所设定的一定量的socket创建和相应的处理线程的创建，然后使用条件变量来完成线程同步，直到最后一个线程创建完成，才向所有线程发出广播通知，让所有线程并发调用connect，连接成功则关闭连接，失败则返回，如下代码所示。socket创建和线程创建：int testCount=300; //并发用户数/*每个进程需要自己独立的栈空间，linux下默认栈大小是10M，在32位的机子上一个进程需要4G的内存空间，去掉自己的栈空间全局程序段空间，一般只有3G内存可以用，创建线程时就需要从这3G的空间中分配10M出来，所以最多可以分配300个线程。当然这里还可以使用多个进程，每个进程300个线程的方式来进一步扩大并发量。*/int sockfd[testCount];pthread_t ntid[testCount];bzero(&servaddr,sizeof(servaddr));servaddr.sin_family=AF_INET;servaddr.sin_port=htons(SERVER_PORT);inet_pton(AF_INET,argv[1],&servaddr.sin_addr);int testCaseIndex=0;for(testCaseIndex=0;testCaseIndex<testCount;testCaseIndex++){sockfd[testCaseIndex]=socket(AF_INET,SOCK_STREAM,0);//为每个并发客户端创建一个socketif(sockfd[testCaseIndex]==-1){printf("socket established error: %s ",(char*)strerror(errno));return -1;}if( pthread_create(&ntid[testCaseIndex],NULL,handleFun,&sockfd[testCaseIndex])!=0){printf("create thread error :%s ",strerror(errno));return -1;}//为每个并发客户端创建一个线程来执行connect}printf("%d client has initiated ",testCaseIndex);并发客户端的线程实现：线程阻塞在条件变量上（只有条件满足了并且发起唤醒动作，线程才开始执行）。int sockfd=*((int*)arg);{pthread_cond_wait(&cond,&mut);//在条件变量上等待条件满足！//阻塞返回后立即解锁，防止互斥量加锁带来的阻塞pthread_mutex_unlock(&mut);int conRes=0;conRes=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));//线程执行connect连接，每个线程在接到唤醒信号后，才可以执行该语句，来模拟多个线程的并发调用。if(conRes==-1){printf("connect error: %s ",strerror(errno));return 0;}}当条件满足时，唤醒阻塞在条件变量上的线程：while(1){sleep(2);pthread_cond_broadcast(&cond); //在所有线程创建完成后才进行唤醒。

电脑计算器没有么？在“查看”里改成“程序员”