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);//条件等待等待
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 
#include 
#include 
#include 
#include 
#include 
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
谢谢这位作者。