欧博allbetAndroid 多线程：Thread理解和使用总结_欧博ABG官网-欧博官方网址-会员登入

Android 多线程：Thread理解和使用总结

Android Thread目录.png

一、Android中的Thread

定义：线程，欧博allbet可以看作是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。

1.1 Thread主要函数函数名作用
run() 线程运行时所执行的代码
start() 启动线程
sleep()/sleep(long millis) 线程休眠，进入阻塞状态，sleep方法不会释放锁（其它线程不会进入synchronized方法体或方法块，不释放锁需要try/catch）
yield() 线程交出CPU，但是不会阻塞而是重置为就绪状态，不会释放锁
join()/join(long millis)/join(long millis,int nanoseconds) 线程插队，当该子线程执行完毕后接着执行其它
wait() 进入阻塞状态，释放锁（其它线程可以进入synchronized方法体或方法块，释放锁不需要try/catch）
interrupt() 中断线程，注意只能中断阻塞状态的线程
getId() 获取当前线程的id
getName()/setName() 获取和设置线程的name
getPriority()/setPriority() 获取和设置线程的优先级，范围1-10，默认是5
setDaemon()/isDaemo() 设置和获取是否守护线程
currentThread() 静态函数获取当前线程
1.2 Thread的几种状态

新建状态（new）：实例化之后进入该状态；

就绪状态（Runnable）：线程调用start()之后就绪状态等待cpu执行，注意这时只是表示可以运行并不代表已经运行；

运行状态（Running）：线程获得cpu的执行，开始执行run()方法的代码；

阻塞状态（Blocked）：线程由于各种原因进入阻塞状态：join()、sleep()、wait()、等待触发条件、等待由别的线程占用的锁；

死亡状态（Dead）：线程运行完毕或异常退出，欧博百家乐可使用isAlive()获取状态。

二、Android中Thread的使用

这里写出三种使用方式：
1. 继承Thread，重写run()方法。
使用时直接new并且start()。（不知道什么时候run()方法变成重写了，以前可是没有 @Override）

public class MyThread extends Thread{ @Override public void run() { super.run(); // do something } } // Thread使用 public void goThread(){ new MyThread().start(); }

2. 实现Runnable，重写run()方法来执行任务。

public class MyRunnable implements Runnable{ @Override public void run() { // do something } } new Thread(new MyRunnable()).start();

另一种启动方式

new Thread(new Runnable() { @Override public void run() { } }).start();

3. 通过Handler启动线程。
首先定义好Handler和Runnable ：

private int count = 0; private Handler mHandler = new Handler(); private Runnable runnable = new Runnable() { @Override public void run() { Log.i("download",Thread.currentThread().getName()+":"+count); count ++; mHandler.postDelayed(runnable,1000); // 执行后延迟1000毫秒再次执行，count已++ } };

然后使用mHandler的post()方法执行线程。当上方的Runnable执行后里面定义了mHandler.postDelayed(runnable,1000);开启延迟1000毫秒后再次执行。

findViewById(R.id.btn_download).setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { mHandler.post(runnable); // handler运行runnable } }); 三、Thread使用其它问题 3.1 如何终止线程

1. 使用boolean变量作为标记
如下，如果变量stop为true则跳出run()方法。关键字volatile表示这个变量随时都有可能发生变化，主要是表示同步，也就是同一时刻只能由一个线程来修改该变量的值。

public class ThreadStopTest extends Thread { public volatile boolean stop = false; @Override public void run() { super.run(); while (!stop){ // thread runing } } }

2. 使用interrupt()
该方法可以用来中断进程，然后就可以终止线程，使用该方法分两种情况，线程正常运行状态和阻塞状态。

（1）线程正常运行状态
要注意的是interrupt()方法只是中断线程而不是结束线程，在线程正常运行状态下使用该方法是不能结束线程的，正确的做法是判断线程是否被中断来决定是否执行代码。这种方法类似于自定义标记。看一下示例：

... // 定义开始和结束线程的方法，与按钮绑定 public void goThread(){ if(null == myThread){ myThread = new MyThread(); } myThread.start(); } private void stopThread() { if(null != myThread && myThread.isAlive()){ myThread.interrupt(); myThread = null; } } public class MyThread extends Thread{ @Override public void run() { super.run(); int i = 0; // 判断状态，如果被打断则跳出并将线程置空 while (!isInterrupted()){ i++; Log.i("thread",Thread.currentThread().getName()+":Running()_Count:"+i); } } }

（2）线程阻塞状态
先看下面的例子，重新写了一个SleepThread，开启和停止的代码省略。这个线程里每间隔1s循环增加i的值并打印。

public class SleepThread extends Thread{ @Override public void run() { super.run(); int i = 0; while(true){ try { i++; Thread.sleep(1000); Log.i("thread",Thread.currentThread().getName()+":Running()_Count:"+i); } catch (InterruptedException e) { e.printStackTrace(); Log.i("thread",Thread.currentThread().getName()+"异常抛出，停止线程"); break; } } } }

当我开始和终止该线程后Log如下：

10-14 19:46:57.562 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142:Running()_Count:1 10-14 19:46:58.562 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142:Running()_Count:2 ... 10-14 19:47:01.564 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142:Running()_Count:5 10-14 19:47:01.931 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142异常抛出，停止线程

可以看到调用interrupt()方法后抛出InterruptedException异常，同时break跳出循环达到停止跑代码的作用。原理是当线程进入阻塞状态时，调用interrupt()方法会抛出异常，利用这个异常来跳出循环。
（3）两种状态一起处理
此外，把两种状态的处理结合在一起是比较好的，这样既可以及时判断线程状态又可以捕获异常来跳出循环。

public class SleepThread extends Thread{ @Override public void run() { super.run(); int i = 0; while(!isInterrupted()){ // 判断线程是否被打断 try { i++; Thread.sleep(1000); Log.i("thread",Thread.currentThread().getName()+":Running()_Count:"+i); } catch (InterruptedException e) { e.printStackTrace(); Log.i("thread",Thread.currentThread().getName()+"异常抛出，停止线程"); break;// 抛出异常跳出循环 } } } }

3. 使用stop()方法终止线程
恕我直言，这个方法就忽略吧，这个相当于强制关机，万一数据丢失得不偿失。

3.2 线程安全与线程同步

1. 什么是线程安全问题
简单地说，线程安全问题是指多个线程访问同一代码或数据，造成结果和数据的错乱或与期望的结果不同所产生的问题。
2. 如何解决线程安全问题

基本上所有的并发模式在解决线程安全问题的问题上，都采用“序列化访问临界资源”的方案，即在同一时刻只能有一个线程访问临界资源（多个线程可能同时访问的数据或资源），也称同步互斥访问。

（1） synchronized 关键字，保证同时刻只有一个线程进入该方法或者代码块，使用方式（Tips：java中有很多方式来实现线程同步，我们常用的synchronized是效率最低的...但是它方便啊）：

线程run()方法中要执行的代码方法添加synchronized关键字，注意要添加在方法的返回值前。

int count = 100; private synchronized void count() { if (count > 0) { Log.e(TAG, Thread.currentThread().getName() + "--->" + count--); } else { isRunning = false; } }

同步代码块的形式使用。

private void count() { synchronized (this) { if (count > 0) { Log.e(TAG, Thread.currentThread().getName() + "--->" + count--); } else { isRunning = false; } } }

（2）特殊域变量volatile修饰变量：告诉虚拟机该变量随时可能更新，因此使用时每次都会重新计算，而不是使用寄存器的值。volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。(不能完全保证线程安全)

private volatile int count = 1000;

（3）使用重入锁实现线程同步。

ReentrantLock() : 创建一个ReentrantLock实例

lock() :获得锁

unlock() : 释放锁

private void count() { lock.lock(); if (count > 0) { Log.e(TAG, Thread.currentThread().getName() + "--->" + count--); } else { isRunning = false; } lock.unlock(); }

（4）ThreadLocal管理变量。如果一个变量使用ThreadLocal进行管理，每一个使用该变量的线程都会获得该变量的副本，副本之间相互独立，所以每个线程都可以修改变量而不会对其它线程造成影响。

private static ThreadLocal<Integer> number = new ThreadLocal<Integer>(){ // 重写方法，设置默认值 @Override protected Integer initialValue() { return 1; } // 自定义方法设置变量值 public void saveNumber(int newNumber){ number.set(number.get() + newNumber); } // 自定义方法获取变量值 public int getNumber(){ return number.get(); } };

相关文章：
Android多线程：理解和简单使用总结

(责任编辑：)

搜索

热门标签:

欧博allbetAndroid 多线程：Thread理解和使用总结