多线程相关

一、Thread

1.通过继承Thread类，重写run方法，调用start开启线程
2.直接new一个Thread类对象，传入一个Runnable对象，调用start开启线程

public class MyThread extends Thread
{@Overridepublic void run() {System.out.println("PS--test Mythread");}
}MyThread myThread = new MyThread();
myThread.start();
//测试以来Runnable接口
new Thread(new MyRunnable()).start();

二、Runnable

1.通过继承Runnable接口，重写run方法，传入Thread方法中调用start开启线程
2.直接new一个Runnable接口对象，传入Thread方法中调用start开启线程

public class MyThread extends Thread
{@Overridepublic void run() {System.out.println("PS--test Mythread");}
}public class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("PS--test MyRunnable");}
}//测试依赖Thread类
MyThread myThread = new MyThread();
myThread.start();
//测试以来Runnable接口
new Thread(new MyRunnable()).start();
//直接使用Runnable
new Thread(() -> System.out.println("PS--test Runnable interface")).start();
/**
*         同上：
*         new Thread(new Runnable() {
*             @Override
*             public void run() {
*                 System.out.println("PS--test Runnable interface");
*             }
*         }).start();
*/

三、线程池

1.简易方法创建

/*** 可缓存无界线程池测试* 当线程池中的线程空闲时间超过60s则会自动回收该线程，核心线程数为0* 当任务超过线程池的线程数则创建新线程。线程池的大小上限为Integer.MAX_VALUE，* 可看做是无限大。*/
ExecutorService threadPoolExecutor1= Executors.newCachedThreadPool();/*** 创建只有一个线程的线程池测试* 该方法无参数，所有任务都保存队列LinkedBlockingQueue中，核心线程数为1，线程空闲时间为0* 等待唯一的单线程来执行任务，并保证所有任务按照指定顺序(FIFO或优先级)执行*/
ExecutorService threadPoolExecutor2= Executors.newSingleThreadExecutor();/*** 创建固定线程数量的线程池测试* 创建一个固定大小的线程池，该方法可指定线程池的固定大小，对于超出的线程会在LinkedBlockingQueue队列中等待* 核心线程数可以指定，线程空闲时间为0*/
ExecutorService threadPoolExecutor3= Executors.newFixedThreadPool(5);/**
* 定时执行任务的线程池
* 创建指定核心线程数，最大线程数是Integer.MAX_VALUE
*/
ExecutorService threadPoolExecutor4= Executors.newScheduledThreadPool(3);
// 创建一个大小为 3 的定时执行任务的线程池
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(3);
// 延迟 2 秒后执行任务
executor.schedule(() -> {System.out.println("Task 1 executed after 1 second");
}, 2, TimeUnit.SECONDS);
// 延迟 2 秒后开始执行任务，之后每隔 3 秒执行一次
executor.scheduleAtFixedRate(() -> {System.out.println("Task 2 executed at fixed rate of 3 seconds");
}, 2, 3, TimeUnit.SECONDS);
// 延迟 2 秒后开始执行任务，之后每隔 3 秒执行一次
executor.scheduleWithFixedDelay(() -> {System.out.println("Task 3 executed after 3 seconds on last task finished");
}, 2, 2, TimeUnit.SECONDS);

2.ThreadPoolEwector创建

线程池的七大参数：
1.核心线程数–corePoolSize
2.最大线程数–maximumPoolSize
当前线程数达到corePoolSize后，如果继续有任务被提交到线程池，会将任务缓存到工作队列中。如果队列也已满，则会去创建一个新线程*来出来这个处理，此时可创建的新线程数量由maximunPoolSize指定。
3.线程存活时间–keepAliveTime
一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在keepAliveTime时间后，这个空闲线程会被销毁
4.线程存活时间单位
5.工作队列–workQueue
新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：
①ArrayBlockingQueue
基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
②LinkedBlockingQueue
基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而基本不会去创建新线程直到maxPoolSize（很难达到Interger.MAX这个数），因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
③SynchronousQueue
一个不缓存任务的阻塞队列，新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
④PriorityBlockingQueue
具有优先级的无界阻塞队列，优先级通过参数Comparator实现。
6.线程工厂–threadFactory
默认工厂 Executors.defaultThreadFactory()
7.拒接策略–handler
当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来则只需拒绝策略
①CallerRunsPolicy
在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。
②AbortPolicy
直接丢弃任务，并抛出RejectedExecutionException异常。
③DiscardPolicy
直接丢弃任务，什么都不做。
④DiscardOldestPolicy
抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (3,8,50,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());
for(int i=0; i<50; i++) {threadPoolExecutor.execute(new MyRunnable());
}

提交线程任务：
execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
submit()方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功，并且可以通过 Future 的 get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
关闭线程池：
shutdown()关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。
shutdownNow()关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。

四、异步代码顺序执行

多个线程异步执行时使多个线程按照先后顺序同步执行。

1.通过join方式

val thread1 = Thread {Log.d("111111", "111111")
}
val thread2 = Thread {Log.d("111111", "222222")
}
val thread3 = Thread {Log.d("111111", "333333")
}
thread1.start()
thread1.join()
thread2.start()
thread2.join()
thread3.start()
thread3.join()

2.通过线程池

val thread1 = Thread {Log.d("111111", "111111")
}
val thread2 = Thread {Log.d("111111", "222222")
}
val thread3 = Thread {Log.d("111111", "333333")
}
val executor = Executors.newSingleThreadExecutor()//创建单个线程的线程池
executor.submit(thread1)
executor.submit(thread2)
executor.submit(thread3)
executor.shutdown()//关闭

五、android中的Handler

1. handler.sendMessage

传递Message信息

//PlanEvent EventListener基本定义，此处不再赘述object EventHandler
{private const val TAG = "EventHandler"//子线程Handlerprivate val eventListeners = listOf<EventListener>().toMutableList()private val workThread: HandlerThread = HandlerThread("EventHandler thread")private var innerEventHandler = object : Handler(workThread.looper) {override fun handleMessage(msg: Message) {super.handleMessage(msg)val bundleData: Bundle = msg.dataval originalText = bundleData.getString("originalText")val source = bundleData.getString("source")val planEvent = PlanEvent(originalText,source!!)synchronized(eventListeners) {eventListeners.forEach { it.onEventData(planEvent) }}Log.d(TAG, "event data: $planEvent")}}fun sendMessage(msg: Message) {innerEventHandler.sendMessage(msg)}fun addEventListener(listener: EventListener) {synchronized(eventListeners) {eventListeners.add(listener)}}fun removeEventListener(listener: EventListener) {synchronized(eventListeners) {eventListeners.remove(listener)}}
}

2.handler.post

post(Runnable runnable)方法接受一个Runnable对象，且runnable的run方法中的操作可在主线程更新，例如执行ui操作
post方法不用调用start

val handler = Handler()
mRunnable = object:Runnable {//可转化为Lambda表达式override fun run() {mChangeValue++mListener?.onChanged(mChangeValue)handler.postDelayed(mRunnable, 2000)//实现一直定时功能}
}
handler.postDelayed(mRunable,2000)