Android NDK开发-----C++基础（多线程、智能指针）
在使用多线程时，首先将pthread配置到项目中，这部分和配置ffmpeg环境一致。
1、pthread环境配置
project ("CMakeProject12")
#所用到的头文件 include文件夹
include_directories("E:/新建文件夹/ndk/pthreads-w32-2-9-1-release/Pre-built.2/include")
#获取动态库 lib文件夹
link_directories("E:/新建文件夹/ndk/pthreads-w32-2-9-1-release/Pre-built.2/lib/x64")
# 将源代码添加到此项目的可执行文件。
add_executable (CMakeProject12 "CMakeProject12.cpp" "CMakeProject12.h")
#添加动态库的可执行文件 lib文件夹中的.lib库
target_link_libraries(CMakeProject12 pthreadVC2)
配置完环境之后，Ctrl + S保存CMakeList.txt文件，在头文件中引入pthread就可以使用线程。
调试过程中，出现未找到pthreadVC2.dll动态库文件，需要去Windows/System32文件夹下添加dll文件。
2、线程的创建
pthread_t pid;
int i = 100;
pthread_create(&pid,0,thread_task,&i);
线程的创建，需要使用pthread_create创建，使用pthread_create需要传入4个参数，第一个参数是pthread_t 的指针，第二个参数先默认给0；第三个参数和第四个参数是匹配的 ，参数3是函数指针，传入void返回void，参数4就是要传入的void值。
void* thread_task(void* args) {
int i = *static_cast<int*>(args);
cout << "线程参数：" << i << endl;
return 0;
}
使用join可使线程执行完毕再执行主线程代码。
pthread_join(pid, 0);
cout << "线程执行完毕" << endl;
下面详细介绍一下各个参数。
参数2：线程属性，pthread_attr_t
pthread_attr_t attr;
//初始化
pthread_attr_init(&attr);
//销毁
pthread_attr_destroy(&attr);
3、分离线程
默认情况下，创建的线程是非分离线程；所谓非分离线程，就是创建的子线程，可以在主线程或者其他线程中，操作该线程的优先级join、sleep等等；
分离线程就是不能被其他的线程操作，像join操作等等，都不可以。
pthread_attr_t attr;
pthread_attr_init(&attr);
//设置为分离线程
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
使用pthread_attr_setdetachstate可以设置线程为分离线程，使用分离线程，那么就不能操作子线程。
4、线程的同步
假设创建10个线程；
queue<int> q;
void* thread_task1(void* args) {
if (!q.empty()) {
printf("获取队列数据：%d", q.front());
q.pop();
}
else {
printf("未获取队列数据");
}
return 0;
}
void test() {
for (size_t i = 0; i < 5; i++)
{
q.push(i);
}
pthread_t pid[10];
//创建10个线程
for (size_t i = 0; i < 10; i++)
{
pthread_create(&pid[i], 0, thread_task1, &i);
}
}
现在的情况是10个线程去获取队列中的数据，目前还未做同步。10个线程同时竞争获取队列中的资源，这样必然会出现线程安全问题。
在Java中，需要加锁完成线程同步，在C++中提供了互斥锁pthread_mutex_t；
pthread_mutex_t mutex;
//初始化锁
pthread_mutex_init(&mutex,0);
......
//销毁锁
pthread_mutex_destroy(&mutex);
在线程中需要加锁
void* thread_task1(void* args) {
//加锁
pthread_mutex_lock(&mutex);
if (!q.empty()) {
printf("获取队列数据：%d", q.front());
q.pop();
}
else {
printf("未获取队列数据");
}
//解锁
pthread_mutex_unlock(&mutex);
return 0;
}
5、手写线程安全的队列
通过前面对于线程同步的安全处理方式，手写一个线程安全的队列。
template typename T;
class SafeQueue {
private:
queue<T> q;
//锁
pthread_mutex_t mutex;
//Java的 wait notify 条件变量
pthread_cond_t cond;
public:
SafeQueue() {
//初始化
pthread_mutex_init(&mutex, 0);
pthread_cond_init(&cond, 0);
}
~SafeQueue() {
//销毁
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
}
void push(T t) {
//加锁
pthread_mutex_lock(&mutex);
q.push(t);
pthread_mutex_unlock(&mutex);
}
void pop(T &t) {
pthread_mutex_lock(&mutex);
if (!q.empty()) {
t = q.front();
q.pop();
}
pthread_mutex_unlock(&mutex);
}
};
以上就是简单的实现线程安全的队列，但是如果我们想要在队列为空的时候，一直等到队列中有数据的时候，就取出数据，那么可以设置条件变量pthread_cond_t
void push(T t) {
//加锁
pthread_mutex_lock(&mutex);
q.push(t);
//当完成push操作的时候，就唤醒 notify
pthread_cond_signal(&cond);
//广播唤醒所有 notifyAll
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mutex);
}
void pop(T &t) {
pthread_mutex_lock(&mutex);
/*if (!q.empty()) {
t = q.front();
q.pop();
}*/
//Java的wait效果
while (q.empty()) {
pthread_cond_wait(&cond, &mutex);
}
t = q.front();
q.pop();
pthread_mutex_unlock(&mutex);
}
在main函数中使用。
SafeQueue<int> sq;
void* push_task(void* args) {
while (1) {
int i;
cin >> i;
sq.push(i);
}
}
void* pop_task(void* args) {
while (1) {
int i;
sq.pop(i);
cout << "取出数据：" << i << endl;
}
}
void main1() {
//创建2个线程
pthread_t pid1, pid2;
pthread_create(&pid1, 0, push_task, 0);
pthread_create(&pid2, 0, pop_task, 0);
}
6、智能指针
一般来说，当在栈中创建一个引用对象，当使用完毕之后，就会被释放。
class A {
public:
A() {
}
~A() {
cout << "被释放" << endl;
}
};
void test() {
A a;
}
当调用test方法之后，a会被释放；当使用new关键字动态申请内存的时候，就需要手动释放。
A *a = new A;
//delete手动释放
delete(a);
但是当使用智能指针的时候，就可以不用手动释放动态分配的内存。
A *a = new A;
shared_ptr<A> sp(a); //a 引用计数 1
shared_ptr<A> sp(a); //a 引用计数 2
使用shared_ptr来修饰指针a，同样也可以释放a。
其中内部的原理就是，在使用shared_ptr来修饰a时，a的引用计数会加1，以此类推，当shared_ptr指针出栈的时候，引用计数会－1，全部出栈则a的引用计数为0，所以a就会被释放。