Java中的多线程分析

一、引言 1. 进程

通俗的来说，进程就是我们打开电脑后使用的一个个的应用程序。比如：打开QQ会启动一个进程，打开浏览器又会启动另一个进程，进程和我们的程序一一对应。关于进程特点，如下：

每个进程对应一定的内存地址空间，并且只能使用它自己的内存空间，各个进程间互不干扰，并且，进程保存了程序每个时刻的运行状态，这样就为进程切换提供了可能
一个进程可以包含多个线程
进程让操作系统的并发性成为可能，但是要注意，一个进程虽然包括多个线程，但是这些线程是共同享有进程占有的资源和地址空间的
进程是操作系统进行资源分配的基本单位，而线程是操作系统进行调度的基本单位。

2. 线程

在出现了进程以后，操作系统的性能得到了大大的提升。虽然进程的出现解决了操作系统的并发问题，但是人们仍然不满足，人们逐渐对实时性有了要求。因为一个进程在一个时间段内只能做一件事情，如果一个进程有多个子任务，只能逐个地去执行这些子任务。所以，线程就应运而生，特点如下：

线程让进程的内部并发成为可能
线程允许在同一个进程中同时存在多个程序控制流，线程会共享进程范围内的资源，但每个线程都有各自的程序计数器、栈以及局部变量等；

在 Java中，一个应用程序对应着一个JVM实例（JVM进程）。Java采用的是单线程编程模型，即在我们自己的程序中如果没有主动创建线程的话，只会创建一个线程，通常称为主线程。但是要注意，虽然只有一个线程来执行任务，不代表JVM中只有一个线程，JVM实例在创建的时候，同时会创建很多其他的线程（比如垃圾收集器线程）。

3. 使用线程会带来哪些问题？ (1). 安全性问题

在线程安全性的定义中，最核心的概念就是正确性。当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么这个类就是线程安全的。

(2). 活跃性问题

活跃性问题关注的是：某件正确的事情最终会发生。导致活跃性的问题包括死锁、饥饿等。

(3). 性能问题

性能问题关注的是：正确的事情能够尽快发生。性能问题包括多个方面，例如响应不灵敏，吞吐率过低，资源消耗过高等。

在多线程程序中，当线程调度器临时挂起活跃线程并转而运行另一个线程时，就会频繁出现上下文切换操作(Context Switch)，这种操作会导致 CPU 时间更多的花在线程调度上而非线程的运行上。

4. 线程的调度策略

如果处于就绪状态的线程获得了CPU，就会开始执行线程的run()方法的任务，则该线程就会处于运行状态。如果计算机只有一个CPU。那么在任何时刻只有一个线程处于运行状态，当然在一个多处理器的机器上，将会有多个线程并行执行；当线程数大于处理器数时，依然会存在多个线程在同一个CPU上轮换的现象。

当一个线程开始运行后，它不可能一直处于运行状态（除非它的线程执行体足够短，瞬间就执行结束了）。线程在运行过程中需要被中断，目的是使其他线程获得执行的机会，线程调度的细节取决于底层平台所采用的策略。对于采用抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务；当该时间段用完后，系统就会剥夺该线程所占用的资源，让其他线程获得执行的机会。在选择下一个线程时，系统会考虑线程的优先级。

所有现代的桌面和服务器操作系统都采用抢占式调度策略，但一些小型设备如手机则可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源，也就是必须由该线程主动放弃所占用的资源。

二、线程的生命周期

Java中 Thread类的各种操作与线程的生命周期密不可分，所以了解清楚线程的生命周期，有助于更好的理解Thread类中的各个方法。

一般来说，线程从最初的创建到最终的消亡，要经历创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、等待(waiting)、时间等待(time waiting) 和消亡(dead/terminated)等状态。在给定的时间点上，一个线程只能处于一种状态。而在线程的生命周期中，各个状态的切换，需要上下文的切换，即通过存储和恢复CPU状态使得其能够从中断点恢复执行。在线程生命周期中，调用各个方法时，要特别关注两个问题：

客户端调用某个方法后，是否会释放锁
客户端调用某个方法后，是否会交出CPU

1. 线程的各个状态

新建状态（new）

当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态。此时仅由 JVM 为其分配内存，并初始化其成员变量的值
就绪状态(runnable)

当线程对象调用了 start()方法之后，该线程处于就绪状态。JVM会为其创建方法调用栈和程序计数器，等待调度运行
运行状态(running)

如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态
阻塞状态(blocked)

当处于运行状态的线程失去所占用资源之后，便进入阻塞状态
消亡(dead)

当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行

2. 线程生命周期分析

当我们需要线程来执行某个子任务时，就必须先创建一个线程。但是线程创建之后，并不会立即进入就绪状态，因为线程的运行需要一些条件（比如程序计数器、Java栈、本地方法栈等），只有线程运行需要的所有条件满足了，才进入就绪状态。当线程进入就绪状态后，不代表立刻就能获取CPU执行时间，也许此时CPU正在执行其他的事情，因此它要等待。当得到CPU执行时间之后，线程便真正进入运行状态。线程在运行状态过程中，可能有多个原因导致当前线程不能继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行）、用户主动让线程等待，或者被同步块阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的时间）、waiting（等待被唤醒）、blocked（阻塞）。当由于突然中断或者子任务执行完毕，线程就会被消亡。

实际上，Java只定义了六种线程状态，分别是 New、 Runnable、 Waiting（主动等待）、Timed Waiting（主动睡眠）、Blocked、Terminated。各状态直接的转换如下图所示：在这里插入图片描述

三、何为上下文切换？

以单核CPU为例，CPU在一个时刻只能运行一个线程。CPU在运行一个线程的过程中，转而去运行另外一个线程，这个叫做线程上下文切换。

由于可能当前线程的任务并没有执行完毕，所以在切换时需要保存线程的运行状态，以便下次重新切换回来时能够紧接着之前的状态继续运行。

举个简单的例子：比如，一个线程A正在读取一个文件的内容，正读到文件的一半，此时需要暂停线程A，转去执行线程B，当再次切换回来执行线程A的时候，我们不希望线程A又从文件的开头来读取。

因此需要记录线程A的运行状态，那么会记录哪些数据呢？因为下次恢复时需要知道在这之前当前线程已经执行到哪条指令了，所以需要记录程序计数器的值，另外比如说线程正在进行某个计算的时候被挂起了，那么下次继续执行的时候需要知道之前挂起时变量的值时多少，因此需要记录CPU寄存器的状态。所以，一般来说，线程上下文切换过程中会记录程序计数器、CPU寄存器状态等数据。

实质上，线程的上下文切换就是存储和恢复CPU状态的过程，它使得线程执行能够从中断点恢复执行，这正是有程序计数器所支持的。

虽然多线程可以使得任务执行的效率得到提升，但是由于在线程切换时同样会带来一定的开销代价，并且多个线程会导致系统资源占用的增加，所以在进行多线程编程时要注意这些因素。

总结：上下文切换要做哪些事？答：需要程序计数器来记录该线程执行到哪条指令，需要寄存器来记录该当前线程挂起时，当前变量的值，以便下次恢复时线程继续执行。

四、线程的创建 1. 线程的创建方式

在 Java中，创建线程一般有两种方式：继承 Thread类和实现 Runnable接口。其中，Thread类本身就实现了 Runnable接口，而使用继承 Thread类的方式创建线程的最大局限就是不支持多继承。特别需要注意两点

实现多线程必须重写run()方法，即在run()方法中定义需要执行的子任务
run()方法不需要用户来调用

线程创建的代码示例：

public class ThreadTest {
	
   public static void main(String[] args) {

       //使用继承Thread类的方式创建线程
       new Thread(){
           @Override
           public void run() {
               System.out.println("Thread");
           }
       }.start();

       //使用实现Runnable接口的方式创建线程
       Thread thread = new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("Runnable");
           }
       });
       thread.start();

       //JVM 创建的主线程 main
       System.out.println("main");
   }
}
Output: (代码的运行结果与代码的执行顺序或调用顺序无关)
      Thread
      main
      Runnable

创建好自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，run() 方法中只是定义需要执行的任务，并且其不需要用户来调用。当通过 start()方法启动一个线程之后，若线程获得了CPU执行时间，便进入run()方法体去执行具体的任务。如果用户直接调用run()方法，即相当于在主线程中执行run()方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。

五、Thread 类详解

Thread类实现了 Runnable接口，在 Thread类中，有一些比较关键的属性，比如name是表示Thread的名字，可以通过Thread类的构造器中的参数来指定线程名字，priority表示线程的优先级（最大值为10，最小值为1，默认值为5），daemon表示线程是否是守护线程，target表示要执行的任务。在这里插入图片描述

1. 与线程运行状态有关的方法 (1). start() 方法

start()方法的作用：用来启动一个线程，当调用该方法后，相应线程就会进入就绪状态，该线程中的run()方法会在某个时机被调用。

(2). run() 方法

run()方法是不需要用户来调用的。当通过start()方法启动一个线程之后，一旦线程获得了 CPU执行时间，便进入run()方法体去执行具体的任务。在这里插入图片描述

注意：创建线程时必须重写run()方法，以定义具体要执行的任务；一般来说，有两种方式可以达到重写run()方法的效果：

直接重写：直接继承Thread类并重写run()方法；间接重写：通过Thread构造函数传入Runnable对象，实际上重写的是 Runnable对象的run() 方法。

####(3). sleep() 方法

sleep()方法的作用是：在指定的毫秒数内让当前正在执行的线程睡眠（即 currentThread()方法所返回的线程），并交出 CPU让其去执行其他的任务。当线程睡眠时间满后，不一定会立即得到执行，因为此时 CPU 可能正在执行其他的任务。所以说，调用sleep()方法相当于让线程进入阻塞状态(blocked)。该方法有如下特征：

使调用该方法的线程暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据，注意该方法要捕捉异常
sleep()是帮助其他线程获得运行机会的最好方法，但是如果当前线程获取到的有锁，sleep()不会让出锁
线程睡眠到期自动苏醒，并返回到可运行状态（就绪），不是运行状态
睡眠线程在苏醒之后，并不会立即执行，所以sleep()中指定的时间是线程不会运行的最短时间，sleep()方法不能作为精确的时间控制

(4). yield() 方法

yield()方法的作用：会让当前线程交出CPU资源，让CPU去执行其他的线程。但是，yield()不能控制具体的交出CPU的时间。需要注意的是：

yield()方法只能让拥有相同优先级的线程有获取 CPU 执行时间的机会
调用yield()方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新得到 CPU 的执行
它同样不会释放锁

public class MyThread extends Thread {

    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i threadObj());

	ObjectLocker lock(threadObj, thread);

	thread->clear_pending_exception();

	java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);

	java_lang_Thread::set_thread(threadObj(), NULL);

	//thread就是当前线程，就是刚才说的thread1线程。
    lock.notify_all(thread);

	thread->clear_pending_exception();
}

至此，thread1线程对象锁调用了notifyall，那么main线程也就能继续跑下去了。

由于 join方法会调用 wait方法让宿主线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。结合 join方法的声明，有以下三条：

join方法同样会让线程交出CPU执行权限
join方法同样会让线程释放对一个对象持有的锁
如果调用了join方法，必须捕获InterruptedException异常或者将该异常向上层抛出

(6). interrupt() 方法

interrupt()的作用：单独调用interrupt()方法可以使得处于阻塞状态的线程抛出一个异常，也就是说，它可以用来中断一个正处于阻塞状态的线程；另外，通过interrupted()方法和isInterrupted()方法可以停止正在运行的线程。interrupt方法在 JDK中的定义为：在这里插入图片描述 interrupted() 和 isInterrupted()方法在 JDK 中的定义分别为：

下面看一个例子：

public class Test {

    public static void main(String[] args) throws IOException  {
        
        Test test = new Test();
        MyThread thread = test.new MyThread();
        thread.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {

        }
        thread.interrupt();
    } 

    class MyThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println("进入睡眠状态");
                Thread.currentThread().sleep(10000);
                System.out.println("睡眠完毕");
            } catch (InterruptedException e) {
                System.out.println("得到中断异常");
            }
            System.out.println("run方法执行完毕");
        }
    }
}
/* Output:
	        进入睡眠状态
	        得到中断异常
	        run方法执行完毕
	 *///~

从这里可以看出，通过interrupt()方法可以中断处于阻塞状态的线程。那么能不能中断处于非阻塞状态的线程呢？看下面这个例子：

public class Test {

    public static void main(String[] args) throws IOException  {
        Test test = new Test();
        MyThread thread = test.new MyThread();
        thread.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {}
        thread.interrupt();
    } 

    class MyThread extends Thread{
        @Override
        public void run() {
            int i = 0;
            while(i

Java中的多线程分析

最近更新

热门博客

[ 申请 ]友情链接：