Android JNI开发（6）--JNI中使用线程

JNI中线程是基于Linux的线程，包含头文件#include< pthread.h>

常用的方法有：

pthread_mutex_t mutex;//互斥锁
pthread_cond_t cond;//条件变量

pthread_mutex_init(&mutex, NULL);
pthread_mutex_lock(&mutex);
pthread_mutex_trylock(&mutex)
pthread_mutex_unlock(&mutex);
pthread_mutex_destroy(&mutex);

pthread_cond_init(&cond, NULL);
pthread_cond_wait(&cond,&mutex);
pthread_cond_signal(&cond);
pthread_cond_broadcast(&cond);
pthread_cond_timedwait(&cond, &mutex, &ts);
pthread_cond_destroy(&cond);

pthread_t native_thread;
pthread_create(&native_thread, NULL, thread_func,NULL);
pthread_join(native_thread, NULL)

大体上就是这么多方法。下面说一下这些方法的作用；

1、互斥锁mutex

（1）初始化

有两种初始化方式：静态、动态；

静态方式：static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态方式：（1）可以使用new或者malloc一个pthread_mutex_t 类型变量，用完后记得delete或者free掉。

（2）调用pthread_mutex_init(&mutex, NULL);即可；第一个参数表示互斥锁变量，第二个参数表示互斥锁属性。成功的话返回0

（2）加锁、解锁、测试加锁

pthread_mutex_lock(&mutex);加锁

pthread_mutex_trylock(&mutex)；//尝试加锁，不常用，和第一个差不多

pthread_mutex_unlock(&mutex);//解锁

不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。

（3）销毁互斥锁

pthread_mutex_destroy(&mutex);执行成功返回0；

2、条件变量

pthread_cond_t表示多线程的条件变量，用于控制线程等待和就绪的条件。

（1）初始化

同样，和互斥锁一样，也有两种初始化方法；

静态方式：static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

动态方式：（1）可以使用new或者malloc一个pthread_cond_t类型变量，用完后记得delete或者free掉。

（2）调用pthread_cond_init(&cond, NULL);即可；第一个参数表示互斥锁变量，第二个参数表示互斥锁属性。成功的话返回0；

（2）等待和触发

等待

pthread_cond_wait(&cond,&mutex);//条件等待等
4000
待

pthread_cond_signal(&cond);//

pthread_cond_broadcast(&cond);

pthread_cond_timedwait(&cond, &mutex, &ts);//时间等待

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()）

的竞争条件（Race Condition）；用法如下：

pthread _mutex_lock(&mutex)
while或if(线程执行的条件是否成立)
pthread_cond_wait(&cond, &mutex);
线程执行.....
pthread_mutex_unlock(&mutex);

触发

激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；

而pthread_cond_broadcast()则激活所有等待线程。

（3）销毁

pthread_cond_destroy(&cond)；

只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。

因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。

3、开启线程

int pthread_create（（pthread_t thread, pthread_attr_t *attr, void （start_routine）（void ）, void *arg）

说明：thread：线程标识符；

attr：线程属性设置；

start_routine：线程函数的起始地址；

arg：传递给start_routine的参数；

返回值：成功，返回0；出错，返回-1。

int pthread_join(pthread_t thread, void **value_ptr);

说明：thread：等待退出线程的线程号。

value_ptr：退出线程的返回值。

使一个线程等待另一个线程结束后，再往下执行。

使用流程

等待线程：
pthread_mutex_lock(&mutex);
if(条件不满足)
　　pthread_cond_wait(&cond, &mutex);
//处理共享资源
pthread_mutex_unlock(&mutex);

激活线程：
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

OK，以上就差不多这么多基础知识，下面直接是代码：

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <iostream>
using namespace std;

int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//该函数增加count数值
void * creator(void * arg)
{
cout << "creator add lock" << endl;
pthread_mutex_lock(&mutex);

count ++;

cout << "in creator count is : " << count << endl;
//条件满足时发送信号
if(count > 0)
{

pthread_cond_signal(&cond);
}

cout << "creator release lock" << endl;

pthread_mutex_unlock(&mutex);

return NULL;

}

//该函数减少count数值
void * consumer(void * arg)
{
cout << "consumer add lock" << endl;

pthread_mutex_lock(&mutex);
//当条件不满足时等待
if(count <= 0)
{
cout << "begin wait" << endl;
pthread_cond_wait(&cond,&mutex);
cout << "end wait" << endl;
}

count --;

cout << "in consumer count is " << count << endl;

pthread_mutex_unlock(&mutex);

cout << "consumer release lock" << endl;

return NULL;

}

int main()
{
//两个线程，一个生产者线程一个消费者线程
pthread_t createthread,consumethread;

pthread_create(&consumethread, NULL, consumer, NULL);
　　 sleep(2);
pthread_create(&createthread, NULL, creator, NULL);

//主进程等待两个线程结束
pthread_join(createthread, NULL);
pthread_join(consumethread, NULL);
return 0;
}

以上参考 ： http://www.cnblogs.com/secondtonone1/p/5580203.html

谢谢这位作者。