Java并发编程（一）线程定义、状态和属性

一 、线程和进程

1. 什么是线程和进程的区别:
线程是指程序在执行过程中，能够执行程序代码的一个执行单元。在java语言中，线程有四种状态：运行 、就绪、挂起和结束。
进程是指一段正在执行的程序。而线程有事也被成为轻量级的进程，他得程序执行的最小单元，一个进程可以拥有多个线程，各个线程之间共享程序的内功空间（代码段、数据段和堆空间）及一些进程级的资源（例如打开的文件），但是各个线程都拥有自己的棧空间。
2. 为何要使用多进程
在操作系统级别上来看主要有以下几个方面：

• 使用多线程可以减少程序的响应时间，如果某个操作和耗时，或者陷入长时间的等待，此时程序讲不会响应鼠标和键盘等的操作，使用多线程后可以把这个耗时的线程分配到一个单独的线程去执行，从而使程序具备了更好的交互性。
• 与进程相比，线程创建和切换开销更小，同时多线程在数据共享方面效率非常高。
• 多CPU或者多核计算机本身就具备执行多线程的能力，如果使用单个进程，将无法重复利用计算机资源，造成资源的巨大浪费。在多CPU计算机使用多线程能提高CPU的利用率。
• 使用多线程能简化程序的结构，使程序便于理解和维护

二、创建线程
多线程的实现一般有以下三种方法其中前两种为最常用的方法：
1. 继承Thread类，重写run()方法
Thread本质上也是实现了Runnable接口的一个实例。需要注意的是调用start()方法后并不是是立即的执行多线程的代码，而是使该线程变为可运行态，什么时候运行多线程代码是由操作系统决定的。
以下是主要步骤：
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。

public class TestThread extends Thread{ 
    public void run() {
            System.out.println("Hello World");
        }  
    public static void main(String[] args) {
        Thread mThread = new TestThread();
        mThread.start(); 
    } 
}

2. 实现Runnable接口，并实现该接口的run()方法
以下是主要步骤：
（1）自定义类并实现Runnable接口，实现run()方法。
（2）创建Thread子类的实例，用实现Runnable接口的对象作为参数实例化该Thread对象。
（3）调用Thread的start()方法来启动该线程。

public class TestRunnable implements Runnable {
    public void run() { 
            System.out.println("Hello World");
        } 
}

public class TestRunnable {
    public static void main(String[] args) {
        TestRunnable mTestRunnable = new TestRunnable();      
        Thread mThread = new Thread(mTestRunnable);
        mThread.start(); 
    } 
}

3. 实现Callable接口，重写call()方法
Callable接口实际是属于Executor框架中的功能类，Callable接口与Runnable接口的功能类似，但提供了比Runnable更强大的功能，主要表现为以下的3点：
（1）Callable可以在任务接受后提供一个返回值，Runnable无法提供这个功能。
（2）Callable中的call()方法可以抛出异常，而Runnable的run()方法不能抛出异常。
（3）运行Callable可以拿到一个Future对象，Future对象表示伊布计算的结果，他提供了检查计算是否完成的方法。由于线程属于异步计算模型，因此无法从别的线程中得到函数的返回值，在这种情况下就可以使用Future来监视目标线程调用call()方法的情况，但调用Future的get()方法以获取结果时，当前线程就会阻塞，直到call()方法的返回结果。

public class TestCallable {  
    //创建线程类
    public static class MyTestCallable  implements Callable {  
        public String call() throws Exception {  
             retun "Hello World";
            }  
        }  
public static void main(String[] args) {  
        MyTestCallable mMyTestCallable= new MyTestCallable();  
        ExecutorService mExecutorService = Executors.newSingleThreadPool();  
        Future mfuture = mExecutorService.submit(mMyTestCallable);  
        try { 
        //等待线程结束，并返回结果
            System.out.println(mfuture.get());  
        } catch (Exception e) {  
           e.printStackTrace();
        } 
    }  
} 

上述程序的输出结果为：Hello World

在这三种方式中，一般推荐实现Runnable接口的方式，其原因是：首先，Thread类定义了多种方法可以被派生类使用重写，但是只有run()方法是必须被重写的，实现这个线程的主要功能，这也是实现Runnable接口需要的方法。其次，一个类应该在他们需要加强或者修改时才会被继承。因此如果没有必要重写Thread类的其他方法，那么在这种情况下最好是用实现Runnable接口的方式。

三、中断线程
当线程的run()方法执行方法体中的最后一条语句后，并经由执行return语句返回时，或者出现在方法中没有捕获的异常时线程将终止。在java早期版本中有一个stop方法，其他线程可以调用它终止线程，但是这个方法现在已经被弃用了。
interrupt方法可以用来请求终止线程，当一个线程调用interrupt方法时，线程的中断状态将被置位。这是没有个线程都具有的boolean标志，每个线程都应该不时的检查这个标志，来判断线程是否被中断。
要想弄清线程是否被置位，可以调用Thread.currentThread().isInterrupted()：

while(!Thread.currentThread().isInterrupted()){
do something
}

但是如果一个线程被阻塞，就无法检测中断状态。这是产生InterruptedException的地方。当一个被阻塞的线程（调用sleep或者wait)上调用interrupt方法。阻塞调用将会被InterruptedException中断。
如果每次迭代之后都调用sleep方法（或者其他可中断的方法），isInterrupted检测就没必要也没用处了，如果在中断状态被置位时调用sleep方法，它不会休眠反而会清除这一状态并抛出InterruptedException。所以如果在循环中调用sleep,不要去检测中断状态，只需捕获InterruptedException。
在很多发布的代码中会发现InterruptedException被抑制在很低的层次上：

void myTask(){
...
try{
sleep(50)
}catch(InterruptedException e){
...
}
}

不要这样做，如果不认为catch中做一处理有什么好处的话，有两种合理的选择：

• 在catch中调用Thread.currentThread().interrup()来设置中断状态。调用者可以对其进行检测
• 更好的选择用throw InterruptedException标记你的方法，不采用try语句块来捕获已成。这样调用者可以捕获这个异常：

void myTask()throw InterruptedException{
sleep(50)
}

四、线程的状态

（1）. 新建状态（New）：新创建了一个线程对象。
（2）. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
（3）. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
（4）. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

• 等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
• 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
• 其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
  （5）. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

这里写图片描述

五、线程的优先级和守护线程

1. 线程优先级
在java中，每一个线程有一个优先级，默认情况下，一个线程继承它父类的优先级。可以用setPriority方法提高或降低任何一个线程优先级。可以将优先级设置在MIN_PRIORITY（在Thread类定义为1）与MAX_PRIORITY（在Thread类定义为10）之间的任何值。线程的默认优先级为NORM_PRIORITY（在Thread类定义为5）。
尽量不要依赖优先级，如果确实要用，应该避免初学者常犯的一个错误。如果有几个高优先级的线程没有进入非活动状态，低优先级线程可能永远也不能执行。每当调度器决定运行一个新线程时，首先会在具有搞优先级的线程中进行选择，尽管这样会使低优先级的线程完全饿死。

2. 守护线程

调用setDaemon(true);将线程转换为守护线程。守护线程唯一的用途就是为其他线程提供服务。计时线程就是一个例子，他定时发送信号给其他线程或者清空过时的告诉缓存项的线程。当只剩下守护线程时，虚拟机就退出了，由于如果只剩下守护线程，就没必要继续运行程序了。
另外JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。