Linux里面自带的多线程方案-posix

thread_posix.c

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <utils/Log.h>
 void *thread_posix_function(void *arg) {
  (void*)arg;
  int i;
  for ( i=0; i<30; i++) {
    printf("hello thread i = %d\n",i);
    ALOGD("hello thread i = %d\n",i);
    sleep(1);
  }
  return NULL;
}
int main(void) {
  pthread_t mythread;
  
  if ( pthread_create( &mythread, NULL, thread_posix_function, NULL) ) {
    ALOGD("error creating thread.");
    abort();
  }
  if ( pthread_join ( mythread, NULL ) ) {
    ALOGD("error joining thread.");
    abort();
  }
  ALOGD("hello thread has run end exit\n");
  exit(0);
}

创建Android.mk

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

LOCAL_SRC_FILES := MyThread.cpp \
	Main.cpp \  
	
LOCAL_SHARED_LIBRARIES :=libandroid_runtime \
	libcutils \
	libutils \
    liblog 	
    
LOCAL_MODULE := android_thread	
LOCAL_PRELINK_MODULE := false
include $(BUILD_EXECUTABLE)

根据LOCAL_MODULE 名称编译,由于没有进行打包,将生成的文件push到机器data/local文件夹下,然后执行该文件

安卓里面Native层自带的多线程类-Thread

MyThread.h 它是声明的一个头文件

#ifndef _MYTHREAD_H
#define _MYTHREAD_H
 
#include <utils/threads.h>
 
namespace android {
 
class MyThread: public Thread {
public:
	MyThread();
    	virtual void        onFirstRef();
        virtual status_t    readyToRun();
	
	//如果返回true,循环调用此函数,返回false下一次不会再调用此函数
	virtual bool threadLoop();
	virtual void        requestExit();
private:
 int hasRunCount = 0;
};
 
}
#endif

MyThread.cpp 它是MyThread.h的实现

#define LOG_TAG "MyThread"
 
#include <utils/Log.h>
#include "MyThread.h"
 
namespace android {
 
	MyThread::MyThread() :
			Thread(false) {
		ALOGD("MyThread");
	}
	  
	bool MyThread::threadLoop() {
		ALOGD("threadLoop hasRunCount = %d",hasRunCount);
		hasRunCount++;
		if (hasRunCount == 10) {
			return false;		
		}
		return true;
	}
	void MyThread::onFirstRef() {
		ALOGD("onFirstRef");
	}
	status_t MyThread::readyToRun() {
		ALOGD("readyToRun");
		return 0;
	}
	void MyThread::requestExit() {
		ALOGD("requestExit");
	}
}

Main.cpp

#define LOG_TAG "Main"
 
#include <utils/Log.h>
#include <utils/threads.h>
#include "MyThread.h"
 
using namespace android;
 
int main()
{
	sp<MyThread>  thread = new MyThread;
	thread->run("MyThread", PRIORITY_URGENT_DISPLAY);
	while(1) {
	   if (!thread->isRunning()) {
		break;	   
	    }	
	}
	ALOGD("main end");
	return 0;
}

sp是Android中的智能指针。智能指针是C++中的一个概念，通过基于引用计数的方法，解决对象的自动释放的问题。
Android.mk

LOCAL_PATH := $(call my-dir)
LOCAL_PRELINK_MODULE := false
include $(BUILD_EXECUTABLE)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := thread_posix.c 
LOCAL_MODULE := linux_thread
LOCAL_SHARED_LIBRARIES :=liblog  
LOCAL_PRELINK_MODULE := false
include $(BUILD_EXECUTABLE)

Android native的Thread类是Android提供的一个基础类，源码路径：
system\core\libutils\include\utils\Thread.h
system\core\libutils\Threads.cpp
该类提供的基础功能涵盖了线程的生命周期：创建、运行、销毁。主要成员函数如下：
0、本身继承于RefBase，所以具有相应的一些特性
// Invoked after creation of initial strong pointer/reference.
virtual void onFirstRef();
1、执行线程创建并启动运行，通过run方法（和java有点差异）：
status_t run(const char name, int32_t priority, size_t stack);
2、循环执行方法
2.1 先执行readyToRun()
2.2 创建完成后，开始执行_threadLoop()函数，该函数主要通过调用threadLoop()函数，因此基类必要要实现threadLoop函数，作为线程执行函数，它是有返回值的方法，而且_threadLoop会根据返回值确定是否继续循环执行的方法。
3、线程请求退出方法
线程销毁，子类最好通过实现requestExit()函数，首先调用Thread类的requestExit()函数，将线程状态mExitPending置为true，然后中断threadLoop：*

安卓里面Native层打印堆栈

1、进入对应的cpp文件，放开#define LOG_NDEBUG 0注释，且变成#define LOG_NDEBUG 1

2、声明头文件
#include<utils/CallStack.h>
#include<utils/Log.h>

3、调用方法：
android::CallStack stack;
stack.update();
stack.log(“lijunbo”); //输出到logcat

4、mk或者bp中需要链接以下so库：
libutils
libcutils