1.最基础的方式就是在需要的时候new一个Thread,但是这种方式不利于线程的管理，容易引起内存泄漏。 试想一下，你在Activity中new一个Thread去处理耗时任务，并且在任务结束后通过Handler切换到UI线程上去操作UI。这时候你的Activity已经被销毁，因为Thread还在运行，所以他并不会被销毁，此外Thread中还持有Handler的引用，这时候必将会引发内存泄漏和crash。
newThread:可复写Thread#run方法，也可以传递Runnable对象 缺点：缺乏统一管理，线程无法复用，线程间会引起竞争，可能占用过多系统资源导致死机或oom。
Thread的两种写法
class ThreadRunable : Thread() {
override fun run() {
Thread.sleep(10000)
}
}
fun testThread(){
Thread{
Thread.sleep(10000)
}.start()
ThreadRunable().start()
}
2.在Android中我们也会使用AsyncTask来构建自己的异步任务。但是在Android中所有的AsyncTask都是共用一个核心线程数为1的线程池，也就是说如果你多次调用AsyncTask.execute方法后，你的任务需要等到前面的任务完成后才会执行。Android已经不建议使用AsyncTask了
@Deprecated
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
使用AsyncTask的方式有以下几种
2.1.继承AsyncTask<String, Int, String>()并且复写他的三个方法
class MyAsyncTask : AsyncTask<String, Int, String>(){
//线程池中调用该方法，异步任务的代码运行在这个方法中，参数代表运行异步任务传递的参数，通过AsyncTask.execute方法传递
override fun doInBackground(vararg params: String?): String {
Log.e(TAG, Thread.currentThread().name)
for(progress in 0..100){
//传递任务进度
publishProgress(progress)
}
return "success"
}
//运行在UI线程上 参数代表异步任务传递过来的进度
override fun onProgressUpdate(vararg values: Int?) {
Log.e(TAG, "progress ${values}, Thread ${Thread.currentThread().name}")
}
//异步任务结束，运行在UI线程上 参数代表异步任务运行的结果
override fun onPostExecute(result: String?) {
Log.e(TAG, "result ${result}, Thread ${Thread.currentThread().name}")
}
}
MyAsyncTask().execute("123")
2.2.直接调用execute方法传递Runable对象
for(i in 0..10){
AsyncTask.execute(Runnable {
Log.e(TAG, "for invoke: ${Thread.currentThread().name} time ${System.currentTimeMillis()}" )
Thread.sleep(10000)
})
}
2.3.直接向线程池添加任务
/**
* 并发执行任务
*/
for(i in 0..10){
AsyncTask.THREAD_POOL_EXECUTOR.execute( Runnable {
Log.e(TAG, "for invoke: ${Thread.currentThread().name} time ${System.currentTimeMillis()}" )
})
}
2.4.其中第三种是并行执行，使用是AsyncTask内部的线程池
@Deprecated
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), sThreadFactory);
threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
3.使用HandlerThread
HandlerThread在内部维护一个loop遍历子线程的消息，允许你向子线程中发送任务
使用方法如下，我们需要先构建HandlerThread实例，并调用start方法，启动内部的loop。
之后需要创建Handler并且将HandlerThread的loop传递进去，在内部实现handleMessage方法处理任务。
fun handlerThread(){
val handlerThread = HandlerThread("Handler__Thread")
handlerThread.start()
//传递的loop是ThreadHandler
val handler = object : Handler(handlerThread.looper){
override fun handleMessage(msg: Message) {
Log.e(TAG, "handlerThread ${Thread.currentThread().name}")
}
}
handler.sendEmptyMessage(1)
}
4.使用IntentService执行完任务后自动销毁，适用于一次性任务（已经被弃用）推荐使用workManager。
/**
* 任务执行完成后自动销毁，适用于一次性任务
*/
class MyIntentService : IntentService("MyIntentService"){
override fun onHandleIntent(intent: Intent?) {
Log.e("MyIntentService", "Thread ${Thread.currentThread().name}")
}
}
5.使用线程池。
线程池是我们最常用的控制线程的方式，他可以集中管理你的线程，复用线程，避免过多开辟新线程造成的内存不足。 线程池的详细解析将在下一章中描述
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler
)
上面是线程池的构造函数
corePoolSize是线程池的核心线程数，这些线程不会被回收。
maximumPoolSize是线程池最大线程数，线程池分为核心线程和非核心线程，两者之和为maximumPoolSize。非核心线程将会在任务执行完后一段时间被释放。
keepAliveTime非核心线程存在的时间。
unit 非核心线程存在的时间单位
workQueue任务队列，在核心线程都在处理任务的时候会将任务存放在任务队列中。只有当任务队列存放满后，才会启动非核心线程。
threadFactory构建线程的工程，一般会在其中处理一些线程启动前的操作。
handler拒绝策略，线程池被关闭的时候（调用shutdonw），线程池线程数等于maximumPoolSize，任务队列已满的时候会被调用。
主要方法
void execute(Runnable run)//提交任务,交由线程池调度
void shutdown()//关闭线程池,等待任务执行完成
void shutdownNow()//关闭线程池，不等待任务执行完成
int getTaskCount()//返回线程池找中所有任务的数量 (已完成的任务+阻塞队列中的任务)
int getCompletedTaskCount()//返回线程池中已执行完成的任务数量 (已完成的任务)
int getPoolSize()//返回线程池中已创建线程数量
int getActiveCount()//返回当前正在运行的线程数量
void terminated() 线程池终止时执行的策略
线程池还有几种内置的方式。
5.1.newFixedThreadPool 创建固定线程数的线程池。核心线程数和最大核心线程数相等为入参。
这种方式创建的线程池，因为使用的是无界LinkedBlockingQueue队列，不加控制的话会引起内存溢出
创建固定线程数的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
5.2.newSingleThreadExecutor 创建一个核心线程数和最大线程数为1的线程池，使用的也是LinkedBlockingQueue。 也会引发内存问题
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
5.3.newCachedThreadPool 创建一个无核心线程，最大线程数无限大的线程池。因为使用的是SynchronousQueue队列，不会存储任务，每提交一个任务就会创建一个新的线程使用。当任务足够多的情况下也会引起内存溢出。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
上述三种方式，其实都不建议。使用线程池应该根据使用的场景，合理的安排核心线程和非核心线程。
