本篇分别从线程的生命周期、线程间通信、线程安全3部分内容学习下线程的使用。
线程生命周期
新建状态（New）
线程刚被创建，但尚未启动。例如，通过Thread t = new Thread();创建了一个线程对象，但尚未调用start()方法。就绪状态（Runnable）
当调用线程对象的start()方法后，线程进入就绪状态，等待CPU调度执行。运行状态（Running）
当线程获得CPU时间片后，进入运行状态，执行run()方法中的代码。阻塞状态（Blocked）
当线程在获取锁或其他资源时被阻塞，会进入阻塞状态。一旦资源可用，线程会重新进入就绪状态。等待状态（Waiting）
通过调用wait()、join()或LockSupport.park()等方法进入等待状态，等待其他线程的操作来唤醒。终止状态（Terminated）
当run()方法执行完毕或因异常退出时，线程进入终止状态。
线程阻塞
线程的阻塞根据不同的造成原因又分为等待阻塞、同步阻塞和其他阻塞。
- 等待阻塞：调用了wait()方法。当调用了wait()方法时，会释放持有对象的锁，只有等待调用notify()/notifyAll()唤醒，才会重新去获取持有对象的锁。
- 同步阻塞：等待同步监视器，而该同步监视器正被其他线程所持有。
- 其他阻塞：如调用了sleep()/join()方法，或调用了阻塞式的IO方法等。当调用了sleep()方法时，不会释放持有对象的锁，直至sleep()结束才被释放。
线程间通信
通常进程的主线程用来处理页面更新等UI相关的操作，如网络请求等耗时操作会开子线程去执行，防止主线程阻塞导致页面卡住，给用户带来不好的体验，子线程执行获得的数据需要显示在UI上，所以需要线程间进行通信。
1. 异步消息处理机制
Android 中的异步消息处理主要由4部分组成：Message、Handler、MessageQueue 和Looper 。
Message
Message 是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间传递数据。Handler
Handler主要是用于发送和处理消息，发送消息一般使用Handler 的sendMessage()方法、post()方法等，发出的消息经过一系列辗转处理，最终会传递到Handler 的handleMessage()方法中。MessageQueue
MessageQueue消息队列主要用于存放所有通过Handler 发送的消息，消息会一直存在于消息队列中等待被处理，每个线程中只有一个MessageQueue对象。Looper
Looper 是每个线程中的MessageQueue的管家，调用Looper 的loop()方法后会进入一个无限循环，每当发现MessageQueue 中存在一条消息就会将它取出传递到Handler 的handleMessage()方法中，每个线程中只有一个Looper对象。
异步消息处理流程：
① 在主线程创建Handler对象，重写handleMessage()方法，该方法做更新UI操作；
② 定义子线程执行耗时操作获取到结果数据，创建Message对象，将结果数据携带在Message对象中，通过主线程Handler对象的sendMessage方法将携带子线程数据的Message对象发给主线程；
③ Message传递到主线程中，在handleMessage中接收并处理数据，实现UI更新。
2. Thread的使用方法
- 常规用法
定义一个线程需要新建一个实现Runnable接口的类，重写父类Thread中的run()方法来实现耗时操作即可。
class MyThread: Runnable{
override fun run() {
// 耗时操作（此处用以100个数字相加为例）
var num = 0
while (num < 100){
num += 1
}
Log.d("cyclicAdd", "num = $num ")
}
}
启动线程是在需要执行耗时操作的地方创建MyThread实例，调用start()方法启动线程，线程中的耗时操作就会开始执行
val myThread = MyThread()
Thread(myThread).start()
- 简单用法
可以不用专门创建类定义线程，可以直接使用Lambda方式定义一个子线程
Thread{
// 耗时操作（此处用以100个数字相加为例）
var num = 100
while (num < 200){
num += 1
}
Log.d("cyclicAdd", "num = $num ")
}.start()
or
thread{
// 耗时操作（此处用以100个数字相加为例）
var num = 100
while (num < 200){
num += 1
}
Log.d("cyclicAdd", "num = $num ")
}
}
- 子线程获取数据，主线程更新UI
做一个逻辑简单的练习，效果是点击按钮更新TextView的text内容，子线程获取到text内容，send至主线程更新UI。
注意：页面销毁时要释放handler资源。
class MainActivity : AppCompatActivity() {
var handler : Handler? = null
val update = 1
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
initView()
initThread()
}
private fun initView(){
btn.setOnClickListener{
thread {
// 执行耗时操作将获取的数据通过arg或obj携带给其他线程
val msg = Message()
msg.what = update
msg.obj = "Nice to meet you!"
handler?.sendMessage(msg)
}
}
}
private fun initThread(){
handler = object : Handler(Looper.getMainLooper()){
override fun handleMessage(msg: Message) {
super.handleMessage(msg)
when(msg.what){
update ->
textview.text = msg.obj.toString()
}
}
}
}
override fun onDestroy() {
super.onDestroy()
// 释放handler资源
handler?.removeCallbacksAndMessages(null)
handler = null
}
}
3. AsyncTask工具实现异步消息处理
AsyncTask是一个抽象类，必须创建子类继承并重写AsyncTask的4个方法执行task：
onPreExecute()
这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作。doInBackground(Params...)
这个方法中的所有代码都会在子线程中运行，在这里去处理所有的耗时任务，可以通过return语句将任务的执行结果返回。onProgressUpdate(Progress...)
当在后台任务中调用了publishProgress（Progress...）方法后，onProgressUpdate （Progress...）方法就会很快被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行更新。onPostExecute (Result)
当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据进行UI操作。
class DownloadTask(context: Context) : AsyncTask<Unit, Int, Boolean>() {
private var num = 0
@SuppressLint("StaticFieldLeak")
val mContext = context
override fun onPreExecute() {
super.onPreExecute()
Toast.makeText(mContext, "UI初始化操作", Toast.LENGTH_SHORT).show()
}
override fun doInBackground(vararg params: Unit?) = try{
// 子线程执行耗时操作
while(true){
val downloadPercent = doDownload()
publishProgress(downloadPercent)
if (downloadPercent >= 10){
break
}
}
true
}catch (e: Exception){
false
}
override fun onProgressUpdate(vararg values: Int?) {
super.onProgressUpdate(*values)
Toast.makeText(mContext, "下载进度 = ${values[0].toString()}", Toast.LENGTH_SHORT).show()
}
override fun onPostExecute(result: Boolean?) {
super.onPostExecute(result)
Toast.makeText(mContext, "下载结果：${result.toString()}", Toast.LENGTH_SHORT).show()
num = 0
}
private fun doDownload() : Int{
return ++num
}
}
MainActivity.kt使用：
private fun initView(){
btn.setOnClickListener{
downloadTask = DownloadTask(this)
downloadTask.execute()
}
}
4. HandlerThread线程的使用
<MainActivity.java>
public class MainActivity extends AppCompatActivity {
private final String TAG = "MainActivity";
private int num = 0;
private Handler work;
private Handler ui;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initHandlerThread();
}
private void initHandlerThread(){
// 创建Handler Thread对象
HandlerThread thread = new HandlerThread("test");
thread.start();
Log.d(TAG, "test Thread id = " + thread.getThreadId());
// 创建线程的handler，用于子线程和主线程进行通信
Handler work = new Handler(thread.getLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
num++;
Log.d(TAG, "work Thread num = " + num);
Message message = new Message();
message.what = num;
// 子线程数据传给主线程
ui.sendMessage(message);
return false;
}
});
ui = new Handler(Looper.getMainLooper()){
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
Log.d(TAG, "ui Thread num = " + msg.what);
if (msg.what < 10){
// 更新UI条件不满足，子线程继续工作
work.sendEmptyMessage(msg.what);
}
}
};
// 触发子线程开始工作
work.sendEmptyMessage(num);
}
}
线程安全
由于多线程之间是同时并发执行的，线程之间的调度又是无序的，会出现类似多个线程同时修改同一个变量的情况，这样线程就是不安全的。
- 线程不安全示例
这里以倒计时为例，先写好线程要执行的操作，然后在主Activity中运行。
<MyRunnable.java>
public class MyRunnable implements Runnable{
private final String TAG = "MyRunnable";
private int num = 10;
@Override
public void run() {
while (num > 0) {
Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d(TAG, "ERROR = " + e);
}
num--;
}
}
}
<MainActivity.java>
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initThread();
}
private void initThread(){
MyRunnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();
new Thread(myRunnable).start();
}
}
【图片】
根据结果可以看出，倒计时会出现重复的情况，此时线程是不安全的。
- 线程安全
为了在多线程环境中对共享资源的访问时互斥的，可以通过加锁来确保线程安全。
- 内置锁 synchronized
synchronized关键字锁是隐式锁，在JVM层实现，线程执行了synchronized 的代码块就自动上了锁，只有线程执行完或线程发生异常时才会释放锁，如果线程中需要等待（IO操作或sleep()），synchronized 不能主动释放锁，会导致资源浪费。
下面代码中synchronized内置锁是对MyRunnable的实例对象起作用的，当一个线程正在执行该实例对象的方法时，另一个线程的执行会变成0，不进入循环内。
<MyRunnable.java>
@Override
public void run() {
// 锁MyRunnable类的对象
synchronized (this) {
while (num > 0) {
Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d(TAG, "ERROR = " + e);
}
num--;
}
}
}
or
@Override
public void run() {
test();
}
// synchronized 修饰方法
private synchronized void test(){
while (num > 0) {
Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d(TAG, "ERROR = " + e);
}
num--;
}
}
【图片】
但是如果创建两个MyRunnable的实例，synchronized就不起作用了，该锁只针对单一的实例对象，无法作用与实例对象和实例对象之间。
private void initThread(){
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
}
【图片】
如果把synchronized (this)改为synchronized (MyRunnable.class)的话，就是给MyRunnable类加锁，而不是该类的实例，这样线程就是同步的，一个线程执行完之后另一个线程再执行，由于实例中有两个MyRunnables实例，所以会执行两次倒计时。
@Override
public void run() {
// 增加锁
synchronized (MyRunnable.class) {
while (num > 0) {
Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d(TAG, "ERROR = " + e);
}
num--;
}
}
}
【图片】
synchronized修饰静态方法不仅同一个MyRunnable实例对讲会线程同步，不同的实例也会线程同步，两个不同的实例最终只执行一次倒计时。
@Override
public void run() {
test();
}
// synchronized 修饰静态方法
private synchronized static void test(){
while (num > 0) {
Log.d(TAG, "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d(TAG, "ERROR = " + e);
}
num--;
}
}
- 重入锁 lock
重入锁lock可以通过ReentrantLock类来实现，ReentrantLock是一种可重入锁，比synchronized更灵活，提供了管理锁的方法，可以主动获取和释放锁。
当同一个MyRunnable对象在不同线程中执行时，加同步锁lock可以实现资源访问互斥。
<Main.java>
private void initThread(){
MyRunnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();
new Thread(myRunnable).start();
}
<MyRunnable.java>
public class MyRunnable implements Runnable{
private int num = 10;
// 创建锁对象
private final Lock lock = new ReentrantLock();
@Override
public void run() {
// 得到锁
lock.lock();
try{
while (num > 0) {
Log.d("====", "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d("===", "ERROR = " + e);
}
num--;
}
}finally {
// 释放锁
lock.unlock();
}
}
}
当两个线程中创建的是不同的两个实例时，每个MyRunnable实例都创建了自己独立的lock锁对象，每个线程使用的不同的锁对象，无法实现限制多线程同时执行的效果，因此需要将锁对象定义为共享的，让所有MyRunnable实例共享一个锁对象。
<Main.java>
private void initThread(){
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
}
<MyRunnable.java>
public class MyRunnable implements Runnable{
private int num = 10;
// 将锁对象定义为静态的，使其成为共享锁
private static final Lock lock = new ReentrantLock();
@Override
public void run() {
// 得到锁
lock.lock();
try{
while (num > 0) {
Log.d("====", "倒计时：" + num + ", thread.id = " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (Exception e) {
Log.d("===", "ERROR = " + e);
}
num--;
}
}finally {
// 释放锁
lock.unlock();
}
}
}
