同步

http://www.cnblogs.com/hustcat/archive/2009/09/01/1558293.html

http://blog.csdn.net/summerhust/article/details/25332331

http://blog.csdn.net/summerhust/article/details/18260117

 

http://hedengcheng.com/?p=803

 

4.互斥锁是为了上锁而设计的，条件变量是为了等待而设计的，信号灯即可用于上锁，也可用于等待，因而可能导致更多的开销和更高的复杂性。 

何谓自旋锁？它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。

 

1、概述
同步问题是操作系统中的经典问题，它伴随着并发处理而自诞生。现代体系结构中常见的并发处理情况可以分为如下三种情况：
(1)多个线程在单处理器上执行——多线程编程
(2)多个线程在多处理器上执行——并行计算
(3)多个线程在分布的多个处理上执行——分布式计算
相应的编程也分成三种情况：
共享变量编程、分布式（基于消息）编程和并行编程。
1.1、并发程序设计的本质
并发程序通常包括两个或多个进程一起工作，共同完成一项任务，于是进程(线程)间的通信产生，也就产生了同步问题。进程(或者线程)间需要通信是产生同步的根本原因，正是因为需要通信，才需要同步。进程之间有两种通信方式：共享变量(shared variables)和消息传递(message passing)。使用共享变量时，一个进程对变量进行写操作，另一个进程进行读操作。使用消息传递时，一个进程发送消息，一个进程接收消息。不管使用哪种通信方式，进程之间需要进行同步。有两种基本的同步方式：互斥(mutual exclusion)和条件同步(condition synchronization)。互斥保证关键代码段不会同一时刻执行。条件同步会阻塞进程，直到相应的条件发生。例如，对于通过共享内存方式来实现通 信生产者和消费者进程，互斥变量保证生产者访问内存时，消费者不会访问内存。条件同步保证生产者写数据之前，消费者不会读数据。
同步的根本目的是创建临界区(critical region）或者等待特定的条件，常用的方式有：锁(lock)、信号量(semaphore)和管程(monitor)。前两者在Linux都有实现，最后一种方式一般在用户态层面实现(比如Java就是采用管程来实现同步原语的)。
    并发编程的硬件来源：中断和多处理器。

 

2、Linux内核同步
Linux内核中产生并发处理的硬件来源有两个：中断和多CPU。其基本同步方式有四种：关闭中断(只对本地CPU)、原 子操作(atomic operation)、自旋锁(spin lock)和信号量。原子操作实际上只是对CPU原子指令的简单包装，它的原子性由硬件保证。而硬件提供的原子指令是实现锁和信号量的基础。
对于 内核态，CPU可能处于两处不同的内核控制路径：中断处理和异常处理(包括系统调用)。对中断处理程序，在单CPU下，可以通过禁止中断实现临界区；在多 CPU下，可以通过自旋锁实现临界区。对异常处理程序，在单CPU下，可以通过禁止内核抢占实现临界区；在多CPU下，可以通过信号量实现临界区。

2.1、自旋锁(spin lock)
自旋锁主要是针对多CPU的，它是一种忙等待形式的同步(所以浪费CPU机器周期)，主要用于中断处理。对于由自旋锁保护的临界区，会禁止内核抢占。对于单CPU，自旋锁除了禁止(或者开启)内核抢占外，什么也不做。

2.1.1、硬件支持
在X86平台下，可以对如下一些指令加上LOCK前缀来保证指令的原子性执行：
 
(1)    位测试修改指令，如BTS,BTR和BTC；
(2)    交换指令XCHG，实际上，对于该指令，即使不加LOCK前缀，也是自动原子执行；
(3)    一些单操作数算术和逻辑运算指令，如INC, DEC ,NOT和NEG；
(4)    一些双操作数指令，如ADD, ADC,SUB,SBB, AND ,OR和XOR。
这些原子操作是实现自旋锁和信号量的基础。

2.1.2、自旋锁的实现
提供的接口如下：

数据结构：

//include/asm-i386/spinlock.h 
/*自旋锁数据结构,2.6.10*/
typedef struct {
    volatile unsigned int lock;
#ifdef CONFIG_DEBUG_SPINLOCK
    unsigned magic;
#endif
} spinlock_t; 

/*从2.6.11开始,与2.6.10有些变化*/
typedef struct {
    volatile unsigned int slock;
#ifdef CONFIG_DEBUG_SPINLOCK
    unsigned magic;
#endif
#ifdef CONFIG_PREEMPT
    unsigned int break_lock;
#endif
} spinlock_t;

接口的实现：

//include/linux/spinlock.h
#define spin_lock(lock)        _spin_lock(lock) 
#define spin_unlock(lock)    _spin_unlock(lock) 

////////////////////////////抢占内核的spin_lock//////////////////////
//kernel/spinlock.c
void __lockfunc _spin_lock(spinlock_t *lock)
{
    preempt_disable(); //禁止内核抢占
    if (unlikely(!_raw_spin_trylock(lock)))
        __preempt_spin_lock(lock);
}

//include/asm-i386/spinlock.h
//返回1表示获得了自旋锁,返回0表示获取自旋锁失败
static inline int _raw_spin_trylock(spinlock_t *lock)
{
    char oldval;
    /*xchgb是原子字令.
    **这些指令相当于:oldval=0;tmp=oldval;oldval=lock->lock;lock->lock=tmp;
    **即读取lock字段的旧值,将将其设为0(即锁住状态)
 旧
    */
    __asm__ __volatile__(
        "xchgb %b0,%1"
        :"=q" (oldval), "=m" (lock->lock)
        :"0" (0) : "memory");
        //如果自旋锁的旧值为正数(即原自旋锁处于unlock状态,当前内核控制中径可以获取锁),则函数返回1,否则返回0
    return oldval > 0;
}
//include/linux/preempt.h
#define preempt_disable() \
do { \
    inc_preempt_count(); \
    barrier(); \
} while (0)

//kernel/spinlock.c
//当前CPU内核控制路径获取自旋锁失败时调用该函数
static inline void __preempt_spin_lock(spinlock_t *lock)
{
    if (preempt_count() > 1) {
        _raw_spin_lock(lock);
        return;
    }

    do {
        //抢占计数器值减1,在等待自旋锁时,允许内核抢占
        preempt_enable();
        while (spin_is_locked(lock))
            cpu_relax();
        preempt_disable();
    } while (!_raw_spin_trylock(lock));//循环请求自旋锁
}

///////////////////////////对于非抢占内核的spin_lock//////////////////////////////
//对于非抢占的内核spin_lock
void __lockfunc _spin_lock(spinlock_t *lock)
{
    //对于非抢占内核,什么也不做
    preempt_disable(); 
    _raw_spin_lock(lock);
}
//include/asm-i386/spinlock.h
static inline void _raw_spin_lock(spinlock_t *lock)
{
#ifdef CONFIG_DEBUG_SPINLOCK
    if (unlikely(lock->magic != SPINLOCK_MAGIC)) {
        printk("eip: %p\n", __builtin_return_address(0));
        BUG();
    }
#endif
    __asm__ __volatile__(
        spin_lock_string
        :"=m" (lock->lock) : : "memory");
}

#define spin_lock_string \    "\n1:\t" \    "lock ; decb %0\n\t" \ #锁计数器值减1    "jns 3f\n" \       #如果小于0,则跳到标号3    "2:\t" \    "rep;nop\n\t" \    #执行空指令    "cmpb $0,%0\n\t" \ #与0比较    "jle 2b\n\t" \     #小于或等于0,则跳到2    "jmp 1b\n" \       #大于0,则跳到1    "3:\n\t"    /////////////////////////spin_unlock的实现/////////////////////////////////        void __lockfunc _spin_unlock(spinlock_t *lock){    _raw_spin_unlock(lock);    preempt_enable();}//include/asm-i386/spinlock.hstatic inline void _raw_spin_unlock(spinlock_t *lock){#ifdef CONFIG_DEBUG_SPINLOCK    BUG_ON(lock->magic != SPINLOCK_MAGIC);    BUG_ON(!spin_is_locked(lock));#endif    __asm__ __volatile__(        spin_unlock_string    );}#define spin_unlock_string \    "movb $1,%0" \        :"=m" (lock->lock) : : "memory"

 

============================

\写在前面：今天一哥们问我，windows的临界代码是自旋还是等待，当时想了想应该是等待，后来翻了一下《Windows via C/C++》，发现还有点小意思。总结一下先。

关 键代码段是指一个小代码段，在代码能够执行前，它必须独占对某些共享资源的访问权。这是让若干行代码能够“以原子操作方式”来使用资源的一种方法。所谓原 子操作方式，是指该代码知道没有别的线程要访问该资源。当然，系统仍然能够抑制你的线程的运行，而抢先安排其他线程的运行。不过，在线程退出关键代码段之 前，系统将不给想要访问相同资源的其他任何线程进行调度。
来看一段使用关键代码段的程序：

const int COUNT = 10;
int g_nSum = 0;
CRITICAL_SECTION g_cs;

DWORD WINAPI FirstThread(PVOID pvParam) {
   EnterCriticalSection(&g_cs);
   g_nSum = 0;
   for (int n = 1; n <= COUNT; n++) {
      g_nSum += n;
   }
   LeaveCriticalSection(&g_cs);
   return(g_nSum);
}


DWORD WINAPI SecondThread(PVOID pvParam) {
   EnterCriticalSection(&g_cs);
   g_nSum = 0;
   for (int n = 1; n <= COUNT; n++) {
      g_nSum += n;
   }
   LeaveCriticalSection(&g_cs);
   return(g_nSum);
}

当 一个线程进入关键代码段，其它请求进入关键代码段的线程就会进入等待状态，这意味着该线程必须从用户方式转入内核方式（大约1000个C P U周期），这种转换是要付出很大代价的。 而对于多CPU系统，有时候这是没有必要的，实际上拥有资源的线程可以在另一个线程完成转入内核方式之前释放资源。
所以，为了提高性能，Microsoft将自旋锁引入关键代码段。当EnterCriticalSection函数被调用时，如果关键代码段已经被其它线程持有时，它就原地自旋，当自旋一定次数后还不能获取关键代码段，此时线程才转入内核方式，进入等待状态。

若要将自旋锁用于关键代码段，应该调用下面的函数，以便对关键代码段进行初始化：

BOOL InitializeCriticalSectionAndSpinCount(
   PCRITICAL_SECTION pcs, DWORD dwSpinCount);

其中，第二个参数dwSpinCount，传递的是在使线程等待之前它试图获得资源时自旋的次数。
Linux的pthread对于线程提供了三种机制，互斥量(mutex)（功能大概相当于Windows的关键代码段），同时为了提高并发性，还引入了读写锁，此外，还提供了条件变量（相应的介绍见《Unix环境高级编程》）。
由于windows的关键代码段工作在用户态， 所以开销应该要小于Linux互斥量。不知道为什么，pthread没有提供自旋锁机制，仅管内核大量的使用自旋锁。

 

============================================================

http://www.cnblogs.com/zhuyp1015/archive/2012/04/29/2476350.html

 

四种进程或线程同步互斥的控制方法

 

1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。

 

2、互斥量:为协调共同对一个共享资源的单独访问而设计的。

 

3、信号量:为控制一个具有有限数量用户资源而设计。

 

4、事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

 

临界区：

 

       不论是硬件临界资源，还是软件临界资源，多个进程必须互斥地对它进行 访问。每个进程中访问临界资源的那段代码称为临界区（Critical Section）（临界资源是一次仅允许一个进程使用的共享资源）。每次只准许一个进程进入临界区，进入后不允许其他进程进入。不论是硬件临界资源，还是 软件临界资源，多个进程必须互斥地对它进行访问。

 

互斥量（Mutex）

 

 

互 斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访 问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。

 

信号量（Semaphores）

 

 

 

信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最大数目。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。

 

 

事件（Event）

 

 

事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。

 

 

总结：

 

1．互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。

 

2．互斥量（Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但对于进程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和线程退出。

 

 =========================================================

一、什么是条件变量

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。

条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件 变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。

 

 

解惑：

1. 为什么cond要和mutex连用？

　　

考虑有这样的情况：

In Thread1:

pthread_mutex_lock(&m_mutex);  

...
pthread_cond_wait(&m_cond,&m_mutex);  

...
pthread_mutex_unlock(&m_mutex); 

 

In Thread2:

pthread_mutex_lock(&m_mutex);  

...
pthread_cond_signal(&m_cond);  

...
pthread_mutex_unlock(&m_mutex);

 是为了应对线 程1在调用pthread_cond_wait()但线程1还没有进入wait cond的状态的时候（也就是说还没有进入等待），此时线程2调用了 cond_singal 的情况（此时线程2就通知线程1 cond 条件已经满足）。 如果不用mutex锁的话，这个cond_singal就丢失了，也就是说线程1收不到该信号，因为此时都还没有进程wait 状态。加了锁的情况是，线程2必须等到 mutex 被释放（也就是 pthread_cod_wait() 进入wait_cond状态 并自动释放mutex） 的时候才能调用cond_singal.

 

2. pthread_cond_wait() 和 pthread_cond_signal()和锁的关系

 

当调用pthread_cond_wait()之后，调用该函数的线程进入睡眠，同时释放mutex

当调用pthread_cond_signal()之后，调用该函数的线程释放mutex

 

 

http://docs.oracle.com/cd/E19253-01/819-7051/sync-13528/index.html

条件变量【用于线程间同步】

使用条件变量可以以原子方式阻塞线程，直到某个特定条件为真为止。条件变量始终与互斥锁一起使用。

使用条件变量，线程可以以原子方式阻塞，直到满足某个条件为止。对条件的测试是在互斥锁（互斥）的保护下进行的。

如果条件为假，线程通常会基于条件变量阻塞，并以原子方式释放等待条件变化的互斥锁。如果另一个线程更改了条件，该线程可能会向相关的条件变量发出信号，从而使一个或多个等待的线程执行以下操作：

• 唤醒

• 再次获取互斥锁

• 重新评估条件

在以下情况下，条件变量可用于在进程之间同步线程：

• 线程是在可以写入的内存中分配的

• 内存由协作进程共享

   

互斥锁(又名互斥量）强调的是资源的访问互斥：互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。

有的时候锁和信号量会同时使用的” 也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。

 

读写锁【适用于一个写，多个读】

　　读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。

　　读写锁可以由三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。

　　在读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。虽然读写锁的实现各不相同，但当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。

　　读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为当前只有一个线程可以在写模式下拥有这个锁。当读写锁在读状态下时，只要线程获取了读模式下的读写锁，该锁所保护的数据结构可以被多个获得读模式锁的线程读取。

　　读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的；当他以写模式锁住时，它是以独占模式锁住的。

虽然读写锁提高了并行性，但是就速度而言并不比互斥量快.

可能这也是即使有读写锁存在还会使用互斥量的原因，因为他在速度方面略胜一筹。这就需要我们在写程序的时候综合考虑速度和并行性并找到一个折中。

比如：  假设使用互斥量需要0.5秒，使用读写锁需要0.8秒。在类似学生管理系统这类软件中，可能百分之九十的
时间都是查询操作，那么假如现在突然来个个20个请求，如果使用的是互斥量，那么最后的那个查询请求被满足需要10后。这样，估计没人能受得了。而使用读写锁，应为读锁能够多次获得。所以所有的20个请求，每个请求都能在1秒左右
得到满足。

也就是说，在一些写操作比较多或是本身需要同步的地方并不多的程序中我们应该使用互斥量，而在读操作远大于写操作的一些程序中我们应该使用读写锁来进行同步

 

条件变量(condition)

　　条件变量一定要与互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生。

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

    条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。

 

===============================================

http://blog.csdn.net/blues1021/article/details/44336797

同步锁的基本原理：

锁基本都是内核对象，用于控制多线程间多进程间的同步访问。

我们知道进程间的同步操作都是要借助内核来完成的，和同一个进程中的线程同步只需要在用户模式下是有很大差别的，当然，对于进程安全的，对于线程肯定也是 安全的，但在用户模式下的线程同步所需消耗的代价相对于通过内核完成的同步是很小的。所以不要利用进程同步的方式来进行同一进程中线程的同步。

同步锁的种类：
互斥量和条件变量。
读写锁，记录锁/文件锁。
信号量。

1.互斥量mutex和条件变量：

lock_the_mutex  //没有获得锁，也会在此阻塞不会浪费CPU轮询

unlock_the_mutex(...);

条件变量：

条件变量，当获取锁后但是条件失败，那么会释放当前锁(另外的线程可以获得锁，以解除死锁)，然后在此阻塞(避免条件判断需要不但轮询浪费CPU时间)。

pthread_mutex_lock(&mutex);　

　　while(条件为假)//当条件不满足时候，解除死锁

　　　　pthread_cond_wait(&cond,&mutex);　// 此处会阻塞，不会浪费CPU资源

　　//..执行某种操作

　　pthread_mutex_unlock(&mutex);

 

pthread_mutex_lock(&mutex);

　　//..设置条件为真

　　pthread_cond_signal(&cond);　　//发送信号,唤醒上述的pthread_cond_wait

　　pthread_mutex_unlock(&mutex);　

 

2.读写锁：

读写锁将锁分为读锁和写锁，是对同步访问方式的划分。

多个线程同步访问一个文件内存都用读锁，那么可以都申请成功。

只要有一个线程申请或拥有写锁，其它线程申请或拥有读锁或者写锁，那么申请写锁的必须等待，或者其它线程申请锁必须等待。

 

3.记录锁/文件锁

记录锁和文件锁是在锁定的内容粒度上面的划分。

记录锁可以锁定文件内存的指定位置的内容上锁，这样内容没有交集的地方，多个线程间访问不用使用同步。

文件锁是锁上整个文件内存，是记录锁的特例。

 

4.信号量

信号量与互斥锁+条件变量相似，它会有一个能否获取锁的判断，获取后判断条件不满足会释放锁，条件满足了又会唤醒等待条件继续获取锁和判断条件；还有指明当前可用资源个数的功能，当拥有个数时才能申请锁成功，0个资源的时候只能等待。当资源个数只能取0和1时候和互斥锁+条件变量一样了。信号量的发明主要是在于进程间的，互斥锁+条件变量主要是用于线程间的，但这些锁都可以用于线程间也都可以用于进程间。

基于内存的信号量一般用于线程间同步; 它是一个进程内堆变量,,随进程的持续性,必须在创建时指定是否在进程间共享(如果为进程间那么变为内核堆变量)。

基于有名信号量一般用于进程间同步;它是一个内核堆变量，随内核有持续性，需手工删除。