Java线程

2018-07-02 本文已影响0人 MyRose

首先了解一下什么是线程，再讨论Java中线程的创建和结束。

一、线程和进程

1.1 线程和进程的区别

线程和进程都是一个时间段的描述，是CPU工作时间段的描述。

进程就是包含上下文切换的程序执行时间总和 = CPU加载上下文+CPU执行+CPU保存上下文

线程是共享了进程的上下文环境，的更为细小的CPU时间段

简而言之，当我们启动一个应用时，要实现这个应用的功能，必然有多条逻辑支持，在具体执行一个程序的时候，会先执行程序的a小段，再执行程序的b小段等等，a、b等就是线程。
在《Java编程思想》中，用了这样一句话来描述：一个线程就是在进程中的一个单一的顺序控制流。

1.2 线程的状态

下图展示了Java中线程的生命周期。

线程的生命周期

可以看出，Java线程具有五种基本状态：New，Runnable，Running，Blocked，Dead。

新建状态(New)：当线程对象创建后，即进入了新建状态，如:Thread t =new MyThread()。（但此时只是创建了线程对象，并没有启动，处于创建状态的线程仅仅分配了内存空间，属于生命周期的初始状态。）
就绪状态(Runnable)：当调用该线程对象的start()方法，线程就进入了就绪状态。（但是并没有执行，只是表示已经做好了准备，等待CPU调度。处于就绪状态的线程具备了除CPU之外运行所需的所有资源。）
运行状态(Running)：当线程获取CPU，执行程序片段，此时线程才得以真正执行，进入了运行状态。(就绪状态是进入到运行状态的唯一入口，即，线程想进入运行状态，必须先处于就绪状态。)
阻塞状态(Blocked)：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时线程进入阻塞状态。( 阻塞状态与就绪状态不同，就绪状态线程只是因为缺少CPU不能继续执行，而阻塞状态是由于各种原因而不能继续执行，不仅仅是缺少CPU。引起阻塞的原因解除后，线程再次转为就绪状态，分配CPU运行。)
阻塞状态可以分为三种：

等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
同步阻塞：线程在获取synchronized同步锁失败（因为锁被其它线程占用），线程进入同步阻塞状态；
其它阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转为就绪转台。

死亡状态(Dead)：线程执行完了或者因异常推出了run()方法，该线程结束生命周期。

二、线程的创建

Android实现子线程主要用两种方式：1、继承Thread类；2、实现Runnable接口。

2.1 Thread类

继承Thread类，并重写run()方法。
启动线程（Thread类的start()方法）

e.g.
MyThread类继承了Thread类，并且在run()方法中执行了网络请求。但是子线程不能对UI做修改，所以讲数据通过Handler发送给主线程，由主线程修改UI。

String url = "http://192.168.1.114:8080/json/get_data.json";  
private TextView tv;  
StringBuffer buffer = new StringBuffer();  
private Handler MyHandle = new Handler() {  
    public void handleMessage(android.os.Message msg) {  
        String json = (String) msg.obj;  
        List<Person> list = parseJsonData(json);  
        for (Person person : list) {  
            buffer.append(person.toString());  
        }  
        tv.setText(buffer.toString());  
    };  
};  
  
@Override  
protected void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
    setContentView(R.layout.activity_main);  
    tv = (TextView) findViewById(R.id.tv_msg);  
    findViewById(R.id.btn_getdata).setOnClickListener(  
            new OnClickListener() {  
  
                @Override  
                public void onClick(View v) {  
                    // TODO Auto-generated method stub  
                    new MyThread().start();  
                }  
            });  
}  
  
class MyThread extends Thread {  
    @Override  
    public void run() {  
        String jsonStr = NetWorkUtils.getData1(url);  
        if (!TextUtils.isEmpty(jsonStr)) {  
            Log.e("jsonStr", jsonStr);  
            Message message = new Message();  
            message.obj = jsonStr;  
            MyHandle.sendMessage(message);  
        }  
    }  
}  
  
  
**  
 * 使用gson解析  
 * @param jsonStr  
 */  
private List<Person> parseJsonData(String jsonStr) {  
    Gson gson = new Gson();  
    List<Person> list = gson.fromJson(jsonStr,  
            new TypeToken<List<Person>>() {  
            }.getType());  
    return list;  
}

2.2 实现Runnable接口

线程可以驱动任务，因此你需要一种描述任务的方式，这可以有Runnable接口来提供。要想定义任务，只需实现Runnable接口并编写run()方法，使得该任务可以执行你的命令。

Runnable只是一个接口，从Runnable导出一个类时，它必须具有run()方法，但是这个方法很普通，不会产生任何内在的线程能力。所以即使实现了Runnable，也无法启动线程，必须依托其它的类。(通常使用Thread类来启动)
所以只是实现Runnable接口并不能启动或者说实现一个线程。

String url = "http://192.168.1.114:8080/json/get_data.json";  
private TextView tv;  
StringBuffer buffer = new StringBuffer();  
private Handler MyHandle = new Handler() {  
    public void handleMessage(android.os.Message msg) {  
        String json = (String) msg.obj;  
        List<Person> list = parseJsonData(json);  
        for (Person person : list) {  
            buffer.append(person.toString());  
        }  
        tv.setText(buffer.toString());  
    };  
};  
  
@Override  
protected void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
    setContentView(R.layout.activity_main);  
    tv = (TextView) findViewById(R.id.tv_msg);  
    findViewById(R.id.btn_getdata).setOnClickListener(  
            new OnClickListener() {  
  
                @Override  
                public void onClick(View v) {  
                    // TODO Auto-generated method stub  
                    new Thread(new MyRunnable()).start();  
                }  
            });  
}  
  
class MyRunnable implements Runnable {  
  
    @Override  
    public void run() {  
         String jsonStr = NetWorkUtils.getData1(url);  
        if (!TextUtils.isEmpty(jsonStr)) {  
            Log.e("jsonStr", jsonStr);  
            Message message = new Message();  
            message.obj = jsonStr;  
            MyHandle.sendMessage(message);  
        }  
    }  
}  
  
  
**  
 * 使用gson解析  
 * @param jsonStr  
 */  
private List<Person> parseJsonData(String jsonStr) {  
    Gson gson = new Gson();  
    List<Person> list = gson.fromJson(jsonStr,  
            new TypeToken<List<Person>>() {  
            }.getType());  
    return list;  
}

三、线程的销毁

有三种方法可以结束线程

设置退出标志，使线程正常退出，即当run()方法完成后线程终止。
使用interrupt()方法中断线程
使用stop方法强行终止线程（不推荐使用，Thread.stop, Thread.suspend, Thread.resume 和Runtime.runFinalizersOnExit 这些终止线程运行的方法已经被废弃，使用它们是极端不安全的！）

3.1 使用退出标志终止线程

使用一个变量来控制循环

public class ThreadSafe extends Thread {
    public volatile boolean exit = false; 
        public void run() { 
        while (!exit){
            //do something
        }
    } 
}

代码中定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false。在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值.

3.2 使用interrupr()方法中断当前线程

使用interrupt()方法中断线程有两种情况

线程处于阻塞状态
在开篇中提到了线程会在什么情况下处于阻塞状态。当调用线程的interrupt()方法时，会抛出InterruptException异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，从而有机会结束这个线程的执行。
通常很多人认为只要调用interrupt方法线程就会结束，实际上是错的，一定要先捕获InterruptedException异常之后通过break来跳出循环，才能正常结束run方法。
e.g.

public class ThreadSafe extends Thread {
    public void run() { 
        while (true){
            try{
                    Thread.sleep(5*1000);//阻塞5妙
                }catch(InterruptedException e){
                    e.printStackTrace();
                    break;//捕获到异常之后，执行break跳出循环。
                }
        }
    } 
}

线程未处于阻塞状态
使用isInterrupted()判断线程的中断标志来退出循环，当使用interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。
e.g.

public class ThreadSafe extends Thread {
    public void run() { 
        while (!isInterrupted()){
            //do something, but no throw InterruptedException
        }
    } 
}

为什么要区分进入阻塞状态和和非阻塞状态两种情况了，是因为当阻塞状态时，如果有interrupt()发生，系统除了会抛出InterruptedException异常外，还会调用interrupted()函数，调用时能获取到中断状态是true的状态，调用完之后会复位中断状态为false，所以异常抛出之后通过isInterrupted()是获取不到中断状态是true的状态，从而不能退出循环，因此在线程未进入阻塞的代码段时是可以通过isInterrupted()来判断中断是否发生来控制循环，在进入阻塞状态后要通过捕获异常来退出循环。因此使用interrupt()来退出线程的最好的方式应该是两种情况都要考虑。
e.g.

public class ThreadSafe extends Thread {
    public void run() { 
        while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
            try{
                Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
            }catch(InterruptedException e){
                e.printStackTrace();
                break;//捕获到异常之后，执行break跳出循环。
            }
        }
    } 
}

3.3 使用stop方法终止线程<不推荐>

程序中可以直接使用thread.stop()来强行终止线程，但stop方法很危险。
原因在于：thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的线程锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁突然释放，那么被保护的数据可能呈现不一致性。其它线程在使用这些被破坏的数据时，可能导致一些很奇怪的应用程序错误。

参考链接：