c/c++线程－－2线程同步

线程同步的方式
1.互斥锁
2.条件变量
3.读写锁

异步方式
信号

同步方式：
3种锁都需要创建和销毁。还有属性参数，默认属性的话，这个参数传NULL。

互斥锁通信机制

• 二元变量，解决线程间同步问题。
• 同步：先后顺序。
• 以排他方式防止数据结构被并发的修改；

控制逻辑：
a.访问前申请，如果处于开锁状态，则申请到该锁，并占有。
如果处于锁定状态，默认阻塞当前线程。
b.只有锁定该互斥锁的线程才能释放该互斥锁，其他线程的操作无效。


初始化，销毁互斥锁
互斥锁，互斥锁属性的变量类型
pthread_mutex_t
pthread_mutexattr_t

///　成功返回0/* Initialize a mutex.  */extern int pthread_mutex_init (pthread_mutex_t *__mutex,       const pthread_mutexattr_t *__mutexattr)     __THROW __nonnull ((1));/* Destroy a mutex.  */extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)     __THROW __nonnull ((1));

申请互斥锁

/// 非阻塞/* Try locking a mutex.  */extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)     __THROWNL __nonnull ((1));/// 阻塞/* Lock a mutex.  */extern int pthread_mutex_lock (pthread_mutex_t *__mutex)     __THROWNL __nonnull ((1));

释放互斥锁

/// !!拥有该锁的线程才能开锁。/* Unlock a mutex.  */extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)     __THROWNL __nonnull ((1));

条件变量通信机制

不仅互斥的访问变量，而且当且仅当满足一定条件时，线程才会执行。
如果只使用互斥锁，那么当出现满足的条件时，还要竞争资源。因此，用互斥锁目标线程可能得不到执行的机会。

条件变量解决：
根据保护数据的当前值来调整线程的行为；类似于信号。
条件变量不能单独使用，必须和互斥锁一起使用。
每个线程对应函数的第一条语句使用锁定互斥量的语句，最后一条语句使用解锁互斥量的语句。

条件变量

pthread_cond_t

pthread_condattr_t

a.创建，销毁

/* Initialize condition variable COND using attributes ATTR, or use   the default values if later is NULL.  */extern int pthread_cond_init (pthread_cond_t *__restrict __cond,      const pthread_condattr_t *__restrict __cond_attr)     __THROW __nonnull ((1));/* Destroy condition variable COND.  */extern int pthread_cond_destroy (pthread_cond_t *__cond)     __THROW __nonnull ((1));

b.等待等待之前要加互斥锁。

阻塞时，隐含释放关联的互斥锁。没唤醒时，隐含加锁。

/* Wait for condition variable COND to be signaled or broadcast.   MUTEX is assumed to be locked before.   This function is a cancellation point and therefore not marked with   __THROW.  */extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,      pthread_mutex_t *__restrict __mutex)     __nonnull ((1, 2));     /* Wait for condition variable COND to be signaled or broadcast until   ABSTIME.  MUTEX is assumed to be locked before.  ABSTIME is an   absolute time specification; zero is the beginning of the epoch   (00:00:00 GMT, January 1, 1970).   This function is a cancellation point and therefore not marked with   __THROW.  */extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,   pthread_mutex_t *__restrict __mutex,   const struct timespec *__restrict __abstime)     __nonnull ((1, 2, 3));

c. 唤醒

隐含释放关联的互斥锁。
即使没有线程相应，也会返回成功。

/// 唤醒一个/* Wake up one thread waiting for condition variable COND.  */extern int pthread_cond_signal (pthread_cond_t *__cond)     __THROWNL __nonnull ((1));/// 唤醒所有/* Wake up all threads waiting for condition variables COND.  */extern int pthread_cond_broadcast (pthread_cond_t *__cond)     __THROWNL __nonnull ((1));    

在我看来，条件变量更像是一种信号。 

程序架构
生产者-消费者

putData()
{
lock();
while(仓库满)
{
wait(hasSlot);
}
put(data);
signal(hasData);
unlock();
}

getData()
{
lock();
while(仓库空)
{
wait(hasData);
}
data = get();
signal(hasSlot);
unlock();
}

读写锁通信机制

互斥锁，条件变量都是互斥的访问临街资源。
对于数据的读写操作来说，写写和读写冲突的。如果只是读操作，那么可以不冲突。
如果采用排他的机制来操作，可能会降低效率。
读写锁，就可以解决这样的问题。和数据库的逻辑一样。

控制逻辑：

• 如果申请了读锁，其他线程也可以申请读锁，但是不能申请写锁。
• 如果申请了写锁，其他线程既不能申请读锁，也不能申请写锁。

读写锁变量
/* Data structure for read-write lock variable handling.  The
   structure of the attribute type is not exposed on purpose.  */
pthread_rwlock_t rwlock;
pthread_rwlockattr_t rwlockattr;

a. 创建，销毁

/* Initialize read-write lock RWLOCK using attributes ATTR, or use   the default values if later is NULL.  */extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,const pthread_rwlockattr_t *__restrict__attr) __THROW __nonnull ((1));/* Destroy read-write lock RWLOCK.  */extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)     __THROW __nonnull ((1));

b. 申请，释放
申请读锁

/* Acquire read lock for RWLOCK.  */extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)     __THROWNL __nonnull ((1));/// 非阻塞/* Try to acquire read lock for RWLOCK.  */extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)  __THROWNL __nonnull ((1));

申请写锁

/* Acquire write lock for RWLOCK.  */extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)     __THROWNL __nonnull ((1));/// 非阻塞/* Try to acquire write lock for RWLOCK.  */extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)     __THROWNL __nonnull ((1));

释放锁--无论是读锁还是写锁

/* Unlock RWLOCK.  */extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)     __THROWNL __nonnull ((1));

说明：

释放逻辑

(1).如果释放读锁，但还有其他线程占用读锁，读锁依然锁定。没有，则解锁。
(2).如果释放写锁，则直接解锁。