JAVA学习-多线程基础

作者: 遇见技术 | 来源:发表于2017-06-06 19:50 被阅读143次

1.简介

对于操作系统而言同时可以允许多个程序，而不同的程序是运行在一个进程中的。而线程(轻量级进程)是程序执行流的最小单位，也可以说一个进程中可以包含多个线程，这些线程共享着进程所拥有的系统资源(CPU,内存等)，因此，可以说进程是操作系统的程序运行过程的抽象，而线程是属于进程的，是程序中一个单一的顺序控制流程。
上面大概介绍了线程的基本信息，而下面会详细的去介绍JAVA中的线程是如何实现的。

2.实现

2.1 实现方式

在JAVA创建线程的方式有两种:实现Runnable接口和继承Thread类，下面将分别介绍这两种方式

1.实现Runnable接口

如下代码所示，为实现Runnable接口创建线程的方式,可以看出这种方式必须重写Runnable接口中的run方法，
如代码，使用实现Runnable接口的方式，创建线程分为两步:
- 创建Runnable实现对象
- 创建Thread对象：值得注意的是thread对象调用start方法将启动线程，运行程序则可以看到输出结果Thread-0,可以看出start方法启动了线程Thread-0
```
public class RunnableTest implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args){
        RunnableTest runnableTest = new RunnableTest();
        Thread thread = new Thread(runnableTest);
        //启动线程
        thread.start();
    }
}
```
2.继承Thread类

如下代码所示，为继承Thread类的方式创建线程的方式，由于当前类是Thread类的子类，则该对象实际就是一个线程对象，故只需要创建该类的实例，启动线程即可，运行代码也可以看到Thread-0的结果，说明同样也启动了线程Thread-0
```
public class ThreadTest extends Thread{

    public void run(){
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args){
        ThreadTest threadTest = new ThreadTest();
        //启动线程
        threadTest.start();
    }
}
```

如上介绍了创建多线程的两种方式，个人觉得实现Runnable接口的方式相对来说比继承Thread类的方式要好，原因如下：

灵活性：由于java是单继承的，假如类A已经继承了类B，如果类A需要变成多线程的，那么只能实现Runnable的方式实现，从这个例子可以发现接口Runnable相对于类Thread方式更加灵活
共享性：实现Runnable接口的方式可以更好的实现数据共享，而继承Thread的方式不行

例如，现在火车站总共有10张车票，3个销售窗口，而每个销售窗口就代表一个线程，可以如下代码所示

public class TrainTicketsTest implements Runnable{

    private static int ticketNum = 10;

    @Override
    public  void run() {
        while(ticketNum > 0){
            System.out.println(Thread.currentThread().getName() + ", ticketNum:" + ticketNum);
            ticketNum--;
        }
    }

    public static void main(String[] args){
        TrainTicketsTest test = new TrainTicketsTest();

        //创建3个线程
        Thread thread1 = new Thread(test);
        thread1.start();

        Thread thread2 = new Thread(test);
        thread2.start();

        Thread thread3 = new Thread(test);
        thread3.start();
    }
}

多线程共享数据

结果如上图所示，在ticketNum=2时同时Thread-0与Thread-1同时访问到了这个变量，从而打印出来的结果一致。

2.2 源码分析

上文中介绍了java中多线程的实现方式,下面我们来详细学习Thread类的源码

2.2.1 类图结构

Thread类图

如上图所示为Thread类的类图结构，其实很简单，就是实现了Runnable接口，下面为JDK文档中对Thread类与Runnable接口的介绍

Thread类：Thread对象是程序中的指向线程，JVM允许应用程序并发的执行多个线程。
Runnable接口：实现Runnable接口的类的实例将被某个线程来执行，实现Runnable接口的类必须重写run方法

2.2.2 构造方法及属性

如下代码所示，为Thead类中的基本属性,看上去有点多，但是耐心的去看觉得还好。

private volatile String name;//线程名称
private int priority;//线程优先级 优先级范围为1-10
private Thread threadQ;
private long eetop;
private boolean single_step;是否为串行
private boolean daemon = false;//是否为守护进程，默认是否
private boolean stillborn = false;//JVM状态
private Runnable target;//run方法执行的对象
private ThreadGroup group;//线程所属于的组
private ClassLoader contextClassLoader;//该线程的上下文类加载器
private AccessControlContext inheritedAccessControlContext;//线程继承的AccessControlContext(用于基于它所封装的上下文作出系统资源访问决定)
private static int threadInitNumber;//对应匿名线程线程号
ThreadLocal.ThreadLocalMap threadLocals = null;//与线程有关的ThreadLocal值，这个map被类ThreadLocal类所持有
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;//与线程有关的inheritableThreadLocals值，这个map被类inheritableThreadLocals类所持有
private long stackSize;//线程请求堆栈的大小，默认为0，和VM相关，有的VM选择忽略这字段
private long nativeParkEventPointer;//在本机线程终止后仍然存在的JVM私有状态
private long tid;//线程id
private static long threadSeqNumber;//用于生成线程id
private volatile int threadStatus = 0;//java线程状态的工具，初始化以指示线程尚未启动
volatile Object parkBlocker;
private volatile Interruptible blocker;
private final Object blockerLock = new Object();
public final static int MIN_PRIORITY = 1;//线程最小优先级
public final static int NORM_PRIORITY = 5;//线程中间优先级
public final static int MAX_PRIORITY = 10;//线程最高优先级

下面将介绍Thread类的构造方法，如下Thread类提供了8个构造方法，它们分别是：

public Thread()：默认的构造方法
public Thread(Runnable target)：接收Runnable实现类的方法
public Thread(ThreadGroup group, Runnable target)：接收指定的线程组与Runnable实现类的方法
public Thread(String name)：指定线程名的方法
public Thread(ThreadGroup group, String name):指定线程组与线程名的方法
public Thread(Runnable target, String name)：接收Runnable实现类与线程名的方法
public Thread(ThreadGroup group, Runnable target, String name)：接收线程组、Runnable实现类、线程名的方法
public Thread(ThreadGroup group, Runnable target, String name,long stackSize)：接收线程组、Runnable实现类、线程名、初始化堆栈容量的方法

上面是Thread类提供的构造方法用于创建Thread对象，通过查看源码可以发现这些构造方法实际上都是调用了init方法，其源码如下所示：

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}

//该方法的功能是初始化一个线程对象，接收了g(所属的线程组),target(执行的对象)
//name(线程名称),stackSize(堆栈初始化容量),acc(指定的类加载器),inheritThreadLocals(用于从本地线程继承初始值)
private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
    //判断线程名称是否为空，为空则抛出异常
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }
    //设置线程名称
    this.name = name;
    
    //获取当前运行的线程
    Thread parent = currentThread();
    //获取系统的安全管理器，安全管理器是一个允许应用程序实现安全策略的类
    SecurityManager security = System.getSecurityManager();
    if (g == null) {//未指定对应的线程组
        
        if (security != null) {
            g = security.getThreadGroup();
        }

        if (g == null) {
            g = parent.getThreadGroup();
        }
    }

    //检查访问权限
    g.checkAccess();
    //是否拥有权限
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }

    g.addUnstarted();
    
    //设置线程组
    this.group = g;
    this.daemon = parent.isDaemon();//设置是否为守护线程，这里的逻辑是创建的线程与其父线程一样
    this.priority = parent.getPriority();//设置线程的优先级
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    this.inheritedAccessControlContext =
            acc != null ? acc : AccessController.getContext();
    this.target = target;//设置target
    setPriority(priority);//覆盖优先级
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;//指定堆栈大小

    /* Set thread ID */
    tid = nextThreadID();//设置线程ID
}

通过以上源码可以看出init方法主要做的事情就是对Thread类的基本属性进行设值，值得注意的是守护线程与线程优先级这两个属性都是与其父线程有关的。

2.2.3 主要流程

上述有介绍到创建线程的方式有两种而这两种方式流程如下：

创建Thread对象：继承Thread类的方式直接创建对象就可以，而实现Runnable接口的方式需要创建Runnable实现的实例作为Thread构造方法的参数
启动线程：调用Thread对象的start方法启动线程
上面提到了调用start方法可以启动线程，下面来分析start方法的源码

public synchronized void start() {
    //判断当前线程的状态，表示线程处于0
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    //将线程添加到线程组中
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
             
        }
    }
}

private native void start0();

通过源码可以看出两点:

首先start() 方法不能调用多次，因为调用多次threadStatus不等于0时会抛出IllegalThreadStateException异常
start方法内部调用本地方法start0创建线程，这里有个疑问在线程调用了start方法启动后是怎么调用run方法的?如下代码其输出结果如下图

public class ThreadTest extends Thread{

    public void run(){
        System.out.println("---------------");
        System.out.println(Thread.currentThread().getName());
        System.out.println("---------------");
    }

    public static void main(String[] args){
        ThreadTest threadTest = new ThreadTest();
        //启动线程
        threadTest.start();
    }
}

输出结果为：

运行结果

通过调试代码可以看出调用start方法后当前共有如下图的线程，其中包括新创建的线程为Thread_0,而还存在main线程与system线程(注意这四个system线程都是守护线程)

线程创建结果

上面有提到一个问题就是线程是如何调用run方法的，通过谷歌，发现Java Thread:揭开Run方法被调用的真正面纱这篇博文介绍的很详细，如想详细了解可以查看，而且本人测试了回到的run方法必须是没有参数的，感兴趣可以去测试下。

2.3 线程状态

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

如上代码所示，在Thread中实际上有个枚举类定义这线程的状态，分别为NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED，总共有6个状态，下面将通过线程的状态转换图分析各个状态的变换过程，如下为线程的状态转换图：

线程状态转换图

下面分别解释下各个状态的：

NEW: 线程尚未启动的状态,
RUNNABLE: 线程处于可运行的状态，当线程处于可运行状态时可能正在JVM中运行也有可能是在等待其他系统资源，例如处理器
BLOCKED: 线程处于等待监视锁的状态，表示线程等待进入或者在调用后重入同步代码块/方法
WAITING: 等待线程的状态，等待状态中的线程正在等待另一个线程执行特定的动作
TIMED_WAITING: 具有指定等待时间的等待线程的线程状态
TERMINATED: 终止线程的状态，线程已完成执行.

3.总结

本文主要介绍了以下几点：

1.线程的两种实现方式及其区别
2.Thread类的基本信息
3.线程创建启动的主要流程，主要是解决心中的疑惑start方法主要干了什么事情，run方法怎么被调用的。
4.线程的状态

这篇文章到此便结束了，如有问题，望指正！下期预告，将会讲解线程中常用的方法及其使用

JAVA学习-多线程基础

1.简介

2.实现

2.1 实现方式

2.2 源码分析

2.2.1 类图结构

2.2.2 构造方法及属性

2.2.3 主要流程

2.3 线程状态

3.总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaAPI

Java学习笔记

程序员