JavaAPIJava学习笔记程序员

JAVA学习-多线程基础

2017-06-06  本文已影响143人  遇见技术

1.简介

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

2.实现

2.1 实现方式

在JAVA创建线程的方式有两种:实现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接口的介绍

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个构造方法，它们分别是：

上面是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 主要流程

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

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

通过源码可以看出两点:

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个状态，下面将通过线程的状态转换图分析各个状态的变换过程，如下为线程的状态转换图：

线程状态转换图

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

3.总结

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

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

上一篇下一篇

猜你喜欢

热点阅读