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(); 
    } 
}123456789

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(); 
    } 
}12345678910111213

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();
        } 
    }  
} 12345678910111213141516171819

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

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

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

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

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

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

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

  • 在 catch 中调用 Thread.currentThread().interrup() 来设置中断状态。调用者可以对其进行检测

  • 更好的选择用 throw InterruptedException 标记你的方法,不采用 try 语句块来捕获已成。这样调用者可以捕获这个异常:

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

四、线程的状态

(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 的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候,使用的数据库连接池,连接池本身也包含着很多后台线程,监控连接个数、超时时间、状态等等