多线程编程-互斥锁

多线程编程-互斥锁 pthread 文章参考

http://blog.chinaunix.net/uid-21411227-id-1826888.htmlhttp://www.2cto.com/kf/201208/151995.html 取了两篇文章的优点

1.引言: 互斥锁,是一种信号量,常用来防止两个进程或线程在同一时刻访问相同的共享资源。可以保证以下三点: 原子性:把一个互斥量锁定为一个原子操作,这意味着操作系统(或pthread函数库)保证了如果一个线程锁定了一个互斥量,没有其他线程在同一时间可以成功锁定这个互斥量。 唯一性:如果一个线程锁定了一个互斥量,在它解除锁定之前,没有其他线程可以锁定这个互斥量。 非繁忙等待:如果一个线程已经锁定了一个互斥量,第二个线程又试图去锁定这个互斥量,则第二个线程将被挂起(不占用任何cpu资源),直到第一个线程解除对这个互斥量的锁定为止,第二个线程则被唤醒并继续执行,同时锁定这个互斥量。 从以上三点,我们看出可以用互斥量来保证对变量(关键的代码段)的排他性访问。

2.函数说明: 需要的头文件:pthread.h 1)初始化互斥锁 函数原型:

int pthread_mutex_init(pthread_mutex_t *mp, const pthread_mutexattr_t *mattr) 参数说明:mp 互斥锁地址 mattr 属性 通常默认 null 初始化互斥锁之前,必须将其所在的内存清零。 如果互斥锁已初始化,则它会处于未锁定状态。互斥锁可以位于进程之间共享的内存中或者某个进程的专用内存中。 2)锁定互斥锁 函数原型: int pthread_mutex_lock(pthread_mutex_t mutex); #include pthread_mutex_t mutex; int ret; ret = pthread_ mutex_lock(&mp); / acquire the mutex */ 函数说明: 当 pthread_mutex_lock() 返回时,该互斥锁已被锁定。调用线程是该互斥锁的属主。如果该互斥锁已被另一个线程锁定和拥有,则调用线程将阻塞,直到该互斥锁变为可用为止。 如果互斥锁类型为 PTHREAD_MUTEX_NORMAL,则不提供死锁检测。尝试重新锁定互斥锁会导致死锁。如果某个线程尝试解除锁定的互斥锁不是由该线程锁定或未锁定,则将产生不确定的行为。 如果互斥锁类型为 PTHREAD_MUTEX_ERRORCHECK,则会提供错误检查。如果某个线程尝试重新锁定的互斥锁已经由该线程锁定,则将返回错误。如果某个线程尝试解除锁定的互斥锁不是由该线程锁定或者未锁定,则将返回错误。 如果互斥锁类型为 PTHREAD_MUTEX_RECURSIVE,则该互斥锁会保留锁定计数这一概念。线程首次成功获取互斥锁时,锁定计数会设置为 1。线程每重新锁定该互斥锁一次,锁定计数就增加 1。线程每解除锁定该互斥锁一次,锁定计数就减小 1。 锁定计数达到 0 时,该互斥锁即可供其他线程获取。如果某个线程尝试解除锁定的互斥锁不是由该线程锁定或者未锁定,则将返回错误。 如果互斥锁类型是 PTHREAD_MUTEX_DEFAULT,则尝试以递归方式锁定该互斥锁将产生不确定的行为。对于不是由调用线程锁定的互斥锁,如果尝试解除对它的锁定,则会产生不确定的行为。如果尝试解除锁定尚未锁定的互斥锁,则会产生不确定的行为。 返回值: pthread_mutex_lock() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,该函数将失败并返回对应的值。 EAGAIN:由于已超出了互斥锁递归锁定的最大次数,因此无法获取该互斥锁。 EDEADLK:当前线程已经拥有互斥锁。 3)解除锁定互斥锁 函数原型: int pthread_mutex_unlock(pthread_mutex_t mutex); #include pthread_mutex_t mutex; int ret; ret = pthread_mutex_unlock(&mutex); / release the mutex */ 函数说明:pthread_mutex_unlock() 可释放 mutex 引用的互斥锁对象。互斥锁的释放方式取决于互斥锁的类型属性。如果调用 pthread_mutex_unlock() 时有多个线程被 mutex 对象阻塞,则互斥锁变为可用时调度策略可确定获取该互斥锁的线程。对于 PTHREAD_MUTEX_RECURSIVE 类型的互斥锁,当计数达到零并且调用线程不再对该互斥锁进行任何锁定时,该互斥锁将变为可用。 返回值:pthread_mutex_unlock() 在成功完成之后会返回零。 其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。 EPERM :当前线程不拥有互斥锁。 4)使用非阻塞互斥锁锁定 函数原型: int pthread_mutex_trylock(pthread_mutex_t mutex); #include pthread_mutex_t mutex; int ret; ret = pthread_mutex_trylock(&mutex); / try to lock the mutex */ 函数说明:pthread_mutex_trylock() 是 pthread_mutex_lock() 的非阻塞版本。如果 mutex 所引用的互斥对象当前被任何线程(包括当前线程)锁定,则将立即返回该调用。否则,该互斥锁将处于锁定状态,调用线程是其属主。 返回值:pthread_mutex_trylock() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,该函数将失败并返回对应的值。 EBUSY : 由于 mutex 所指向的互斥锁已锁定,因此无法获取该互斥锁。 EAGAIN:描述: 由于已超出了 mutex 的递归锁定最大次数,因此无法获取该互斥锁。 5)销毁互斥锁 函数原型: int pthread_mutex_destroy(pthread_mutex_t mp); #include pthread_mutex_t mp; int ret; ret = pthread_mutex_destroy(&mp); / mutex is destroyed */请注意,没有释放用来存储互斥锁的空间。 返回值: pthread_mutex_destroy() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,该函数将失败并返回对应的值。 EINVAL: mp 指定的值不会引用已初始化的互斥锁对象。

3.例子:

include

include

include

include

include

// 线程ID
pthread_t ntid;
// 互斥对象
pthread_mutex_t mutex;
int count;
void printids(const char *s)
{
pid_t pid;
pthread_t tid;
pid = getpid();
tid = pthread_self();
printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,
(unsigned int)tid, (unsigned int)tid);
}

// 线程函数
void thr_fn(void *arg)
{
printids("new thread begin\n");
// 加锁
pthread_mutex_lock(&mutex);
printids("new thread:");
int i=0;
for ( ; i < 5; ++i )
{
printf("thr_fn runing %d\n", count++);
}
// 释放互斥锁
pthread_mutex_unlock(&mutex);
return ( (void
)100);
}

int main(void)
{
int err;
count = 0;
// 初始化互斥对象
pthread_mutex_init(&mutex, NULL);
// 创建线程
err = pthread_create(&ntid, NULL, thr_fn, NULL);
if ( 0 != err )
{
printf("can't create thread:%s\n", strerror(err));
}
// sleep(5);
pthread_mutex_lock(&mutex);
printids("main thread:");
int i=0;
for ( ; i < 5; ++i )
{
printf("main runing %d \n", count++);
}
sleep(1);
pthread_mutex_unlock(&mutex);
int ret;
pthread_join(ntid, (void
)ret);
printf("thr_fn return %d\n", *ret);
pthread_mutex_destroy(&mutex);
return 0;
}
这个例子,用到了pthread的数据结构: pthread_t, 这个结构来标识线程ID; pthread_mutex_t, 这个用来做互斥; 用到了如下函数: pthread_self() : 获得线程自身的ID; pthread_create(&ntid, NULL, thr_fn, NULL): 线程创建函数 原型: int pthread_create(pthread_t thread, const pthread_attr_t *attr, void*(*start_routine)(void), void *arg)
* tid : 新创建线程的线程ID;
* attr: 指定新创建线程的线程属性,为NULL即为使用默认属性;
* start_routine : 这是一个函数指针,用来指向线程函数;
* arg : 传递给线程函数的指针 返回值 : 0代表成功。 失败,返回的则是错误号。

pthread_join(ntid, (void*)ret):等待一个线程的结束 原型: int pthread_join(pthread_t thread, void **retval);
* thread : 需要等待的线程的ID;
* retval : 存放等待线程的返回值; 返回值 : 0代表成功。 失败,返回的则是错误号。

pthread_mutex_init(&mutex, NULL):初始化互斥锁,以动态方式创建互斥锁 原型: int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
* mutex : 被初始化的锁对象;
* attr : 指定新建互斥锁的属性。为NULL,则使用默认的互斥锁属性,默认属性为快速互斥锁。
* pthread_mutex_lock(&mutex) : 加锁
* pthread_mutex_unlock(&mutex) : 释放锁
* pthread_mutex_destroy(&mutex): 销毁锁对象 编译的时候,需要加上编译参数“-lpthread”。 可以屏蔽pthread_mutex_lock(),pthread_mutex_unlock()看下没有互斥的结果。 pthread_craete()出来的线程,joinable或detached两者必占之一。 如果是jionale的线程,那么必须使用pthread_join()等待线程结束,否则线程所占用的资源不会得到释放,会造成资源泄露。如果想创建一个线程,但又不想使用pthread_join()等待该线程结束,那么可以创建一个detached的线程。detached状态的线程,在结束的时候,会自动释放该线程所占用的资源。 detached不需要,也不能使用pthread_join()来等待线程结束。 另外,一个jionale线程,只能有一个pthread_jion()来等待结束,如果有多个,则只有第一个执行到的有效,其他的都会直接返回,具体错误信息由pthread_join()函数的返回值返回。 上代码,主要是joinable及detached状态线程的创建,同一线程多个pthread_join(),pthread_join()一个detached线程

include

include

include

include

include

// 线程ID
pthread_t ntid_joinable;
pthread_t ntid_detached;
// 互斥对象
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int count;

void printids(const char *s)
{
pid_t pid;
pthread_t tid;

pid = getpid();
tid = pthread_self();

printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,
(unsigned int)tid, (unsigned int)tid);
}

// 线程函数
void *thr_joinablefn(void *arg)
{
printids("new thread thr_joinablefn begin\n");

// 加锁
pthread_mutex_lock(&mutex);

printids("new thread thr_joinablefn:\n");

int i=0;
for ( ; i<5; ++i)
{
printf("thr_joinablefn runing %d\n", count++);
sleep(1);
}

// 释放互斥锁
pthread_mutex_unlock(&mutex);

return ( (void*)555);
}

// 线程函数
void *thr_detachedfn(void *arg)
{
printids("new thread thr_detachedfn begin\n");

// 加锁
//pthread_mutex_lock(&mutex);

int err;
int ret;
err = pthread_join(ntid_joinable, (void
)ret);
if ( err == 0 )
{
printf("thr_joinablefn return in thr_detachedfn %d\n", *ret);
}
else
{
printf("can't pthread_join ntid_joinable thread in thr_detachedfn :%s\n", strerror(err));
}

printids("new thread thr_detachedfn:\n");

int i=0;
for ( ; i<10; ++i)
{
printf("thr_detachedfn runing %d\n", count++);
sleep(1);
}

// 释放互斥锁
//pthread_mutex_unlock(&mutex);

return ( (void*)666);
}

int main(void)
{
int err;

count = 0;
// 初始化互斥对象
pthread_mutex_init(&mutex, NULL);

// 创建joinable线程
// pthread_craete第二个参数为NULL,则创建默认属性的线程,此时为PTHREAD_CREATE_JOINABLE
err = pthread_create(&ntid_joinable, NULL, thr_joinablefn, NULL);
if ( 0 != err )
{
printf("can't create ntid_joinable thread:%s\n", strerror(err));
}

// 创建detached线程
pthread_attr_t attr;
pthread_attr_init(&attr);
// 如果下句的 PTHREAD_CREATE_DETACHED 改为 PTHREAD_CREATE_JOINABLE
// 则该线程与上面创建的线程一样
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
err = pthread_create(&ntid_detached, &attr, thr_detachedfn, NULL);
if ( 0 != err )
{
printf("can't create thr_detachedfn thread:%s\n", strerror(err));
}
pthread_attr_destroy (&attr);

int ret;
err = pthread_join(ntid_joinable, (void
)ret);
if ( err == 0 )
{
printf("thr_joinablefn return %d\n", *ret);
}
else
{
printf("can't pthread_join ntid_joinable thread:%s\n", strerror(err));
}

err = pthread_join(ntid_detached, (void**)ret);
if ( err == 0 )
{
printf("ntid_detached return %d\n", *ret);
}
else
{
printf("can't pthread_join ntid_detached thread:%s\n", strerror(err));
}

pthread_mutex_destroy(&mutex);

return 0;
}

4.饥饿和死锁的情形 当一个互斥量已经被别的线程锁定后,另一个线程调用pthread_mutex_lock()函数去锁定它时,会挂起自己的线程等待这个互斥量被解锁。可能出现以下两种情况: “饥饿状态”:这个互斥量一直没有被解锁,等待锁定它的线程将一直被挂着,即它请求某个资源,但永远得不到它。用户必须在程序中努力避免这种“饥饿”状态出现。Pthread函数库不会自动处理这种情况。 “死锁”:一组线程中的所有线程都在等待被同组中另外一些线程占用的资源,这时,所有线程都因等待互斥量而被挂起,它们中的任何一个都不可能恢复运行,程序无法继续运行下去。这时就产生了死锁。Pthread函数库可以跟踪这种情形,最后一个线程试图调用pthread_mutex_lock()时会失败,并返回类型为EDEADLK的错误。

1 thought on “多线程编程-互斥锁

发表评论

电子邮件地址不会被公开。 必填项已用*标注

This site uses Akismet to reduce spam. Learn how your comment data is processed.