Java多线程机制——多线程概述

96
Mr_Yanger
2017.11.28 21:11* 字数 2147

本文概述

本篇文章将分四块内容对Java中的多线程机制进行介绍:
一. 多线程概述
二. 实现多线程的两种方式
三. 多线程的生命周期
四. 线程调度和控制

一. 线程与进程的概述

  线程是依赖于进程而存在的,因此在讨论线程之前,我们必须要知道什么是进程

1. 什么是进程

  进程就是正在运行的程序,是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。当我们打开电脑资源管理器时,就可以显示当前正在运行的所有进程。

2. 多进程的意义

  大家应该有过这样的经历:我可以同时在电脑上做很多事情,比如我可以一边玩游戏,一边听音乐,网速够快我还可以同时用迅雷下载电影。这是因为我们的操作系统支持多进程,简而言之就是:能在同一时段内执行多个任务
  需要注意的是,对于单核计算机来讲,游戏和听音乐这两个任务并不是“同时进行”的,因为CPU在某个时间点上只能做一件事情,计算机是在游戏进程和音乐进程间做着频繁切换,且切换速度很快(也就是轮流执行CPU时间片),所以,我们感觉游戏和音乐好像在“同时”进行,其实并不是同时执行的。

CPU占用率
  多进程的作用不是提高执行速度,而是提高CPU的使用率

3. 什么是多线程

  在一个进程内部又可以执行多个任务,而这每一个任务我们就可以看成是一个线程。
  下面是一段代码示例:

public class Demo {
     public static void main(String args[]) {
              //代码段1
              do();
              //代码段2 
          }
      public static void do() { 
              //代码段11

              function1();
              function2();
              //代码段22
          }
      public static void function1(){...}
      public static void function2(){...}
}

如果是单线程的执行方式:是一条执行路径


单线程方式.png

如果是多线程的执行方式:有多条执行路径


多线程方式.png
  1. 是进程中的单个顺序控制流,是一条执行路径。
  2. 一个进程如果只有一条执行路径,则称为单线程程序。
  3. 一个进程如果有多条执行路径,则称为多线程程序。

4. 多进程的意义

  多线程的作用不是提高执行速度,而是为了提高应用程序的使用率。

并行:逻辑上同时发生,指在某一段时间段同时运行多段程序
并发:物理上同时发生,指在某一个时间点同时运行多段程序

  多线程却给了我们一个错觉:让我们认为多个线程是并发执行的。其实不是:多个线程共享同一个进程的资源,但是栈内存是独立的,一个线程一个栈。所以他们仍然是在抢CPU的资源执行。一个时间点上只有能有一个线程执行。而且谁抢到,这个不一定,所以,造成了线程运行的随机性其中的某一个进程如果执行路径比较多的话,就会有更高的几率抢到CPU的执行权。

5. Java中的多线程

  Java程序运行会启动JVM,相当于启动了一个进程,该进程会自动启动一个 “主线程” ,而main方法就运行在这个主线程当中,所以我们之前写的程序都是单线程。

思考:JVM启动是单线程还是多线程?
答案:多线程,JVM一定会启动主线程和垃圾处理机制,所以一定是多线程

二. 实现多线程的两种方式

1. 多线程实现方式V1.0(继承Thread类)

根据API文档查询可以得到创建多线程的方法:

  1. 自定义类继承Thread类
  2. 该子类重写子类的run()方法
  3. 并启动该子类的实例。
  4. 调用实例的start方法

放在run方法中的代码会被线程执行

注意:run()方法实际上是单线程,不能直接调用run()方法,要先看到多线程的效果,必须使用start()方法。run()仅仅只是被封装的执行代码,而是普通方法,然而start方法会先启用线程,然后再用jvm去调用线程的run方法
因此:要启动多线程,一定要调用start()方法,不能使用run()方法

子线程1(Thread1):
public class FirstThread extends Thread{
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("Thread1\t" + i);
        }
    }
}
子线程2(Thread2):
public class SecondThread extends Thread{
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("Thread2\t" + i);
        }
    }
}
main函数
public class MyThreadDemo {
    public static void main(String args[]) {
        Thread t1 = new FirstThread();
        Thread t2 = new SecondThread();
        t1.start();
        t2.start();
    }
}

2. 多线程实现方式V2.0(实现Runnable接口)

  1. 自定义类MyRunnerble()实现Runnable接口
  2. 在MyRunnerble中重写run()方法
  3. 创建MyRunnerble的实例对象
  4. 将所创建的对象作为参数传入到Thread当中
public class MyThreadDemo2 {
    public static void main(String args[]) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 100; i++) {
                    System.out.println("thread1" + i);
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 100; i++) {
                    System.out.println("thread2" + i);
                }
            }
        });
        t1.start();
        t2.start();
    }
}

3. 两种创建方式的比较

  既然有了方式一,为什么又要有方式二呢?
  比较两种创建方式,我们不难发现,第一种方式是通过继承的方式实现的,第二种方式是通过接口的方式实现。

继承Runnerble接口的优点:
  1. 可以避免Java单继承带来的局限性。
  2. 适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,数据有效的分离,较好体现了面向对象的设计思想。

三. 多线程的生命周期

  多线程的生命周期如下图所示:


线程生命周期图.png

四. 线程调度和控制

1. 线程调度

  如果我们的计算机只有一个 CPU,那么 CPU 在某一个时刻只能执行一条指令,线程只有得到 CPU时间片,也就是使用权,才可以执行指令。那么Java是如何对线程进行调用的呢?

线程调度的两种模式

  1. 分时调度模式:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片。
  2. 抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。

Java采用的是抢占式调度模式,用优先级控制时间片轮转
设置和获取优先级的方式如下:

public final int getPriority()
public final void setPriority(int newPriority)

2. 线程的控制

2.1 线程休眠

  相当于在线程中暂停了几秒

方法:
public static void sleep(long millis)
示例
public class SecondThread extends Thread{
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            System.out.println("线程2");
    }
}
注意

该方法是静态方法,可以通过类直接调用,而且会抛出异常。

2.2 线程加入

为了让某些需要执行的线程执行完毕,别的线程才能拿够继续

方法
public final void join()
示例
public class MyThreadDemo {
    public static void main(String args[]) {
        Thread t1 = new FirstThread();
        Thread t2 = new SecondThread();
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}
注意

只有当t1线程执行完毕之后才会执行第二个线程,要注意该方法也会抛出异常。

2.3 线程礼让

暂停执行当前线程,并执行其他线程,在一定的程度上能够交替执行,但不能保证一定是交替执行的

方法
public static void yield()
注意

使用方法与之前类似,该方法是静态方法,所以直接可以通过类调用

2.4 后台线程(守护线程)

将该线程标记为守护线程或者是用户线程,当正在运行的线程都是守护线程时,java虚拟机退出。

方法
public final void setDaemon(boolean on)
示例:
public class MyThreadDemo {
    public static void main(String args[]) {
        Thread t1 = new FirstThread();
        Thread t2 = new SecondThread();
        Thread t3 = new ThirdThread();
        t1.setDaemon(true);//将t1设置为守护进程
        t2.setDaemon(true);//将t2设置为守护进程
        t1.start();
        t2.start();
        t3.start();
    }
}
注意:

该方法只能够在开启线程之前使用,而且不能立即停止,有一定的延迟。

2.5 线程中断

中途关闭线程

方法
public final void stop()//过时了,但是还是可以使用的,不安全不建议使用
public void interrupt()//他让我们抛出一个异常,如果受阻,那么状态终止,抛出异常

总结

  多线程是Java各种机制中非常重要也是比较陌生的一块内容,需要对计算机操作系统运行机制有一定了解的情况下才能深入理解,之后的文章会对多线程的安全,死锁和与线程有关的设计模式做更深入的介绍,欢迎继续观看后续内容,一起体会Java语言的智慧与魅力。

Java程序设计系列教程