高并发专题（二）--java中的线程

Java中的线程

线程的创建

        我见过不少的言论和题目，对于在java中创建线程一直众说纷纭。但是大多数的言论倾向于三种创建方式（除了线程池的方式）。分别是继承Thread，实现Runnable和使用Callable和Future。我以前也对此深信不疑，直到我在看视频的时候，大佬带我简单瞄了一下线程的启动代码，我对此这种说法就不完全信了。直到我看到了汪文君老师的著作的时候，我内心更倾向于汪文君老师的言论。
        线程的创建方式是由操作系统所决定的，而在java中，唯一的入口就是本地方法start0。而上述我们所说的三种方式最终都会创建一个对象，这个对象是Thread的一个实例对象，再由这个实例对象调用start方法，最终调用本地方法start0。因此我借用汪文君老师的言论：java创建线程只有一种，就是创建一个Thread的实例。再由Thread的实例调用start方法。
        那么实现Runnable接口是怎么一回事呢？无论是继承Thread的时候，或者实现Runnable接口也好，我们通常都会重写run方法，这样线程就会按照我们run方法内部的逻辑去执行了。这是因为当线程启动后，线程会回调这个run方法。这就是实现Runnable接口创建线程的谣言的原因吧。但是只是实现Runnable接口是没用的，你还是缺少Thread的一个实例去调用start方法。
        至于Callable和Future接口，则是通过Runnable接口扩展的，在实现Callable接口时，我们只需要重写一个带返回值的call方法即可。在创建Future的实现的时候，我们会将一个Callable的实现传入进去。Future的实现中我们一般使用的是FutureTask。它同时也是Runnable的实现之一，在重写的run方法中，它会回调设置的Callable的实例call的方法，并将其返回赋值给一个成员变量outcome。

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;//将成员变量的callable赋值给局部变量
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();//调用callable的call方法，并且将返回值赋给result
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);//执行成功后将结果设置给成员变量
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
protected void set(V v) {//set方法的具体实现
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

        总而言之，线程的创建时通过Thread的实例的start方法调用本地方法start0，再由start0方法执行成功后调用run方法。可以这么认为，线程的创建只有start0方法。而想要控制线程中的执行逻辑可以使用继承Thread类重写run方法，实现Runnable接口实现run方法以及实现Callable的call方法，并将Callable实例封装成一个FutureTask。最后通过Thread的实例start方法执行。

线程的状态

线程的状态值在内部的一个枚举中定义了。

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

        java的线程一共有六种状态。
        NEW:线程只是做个一个创建实例的动作。
        RUNNABLE:线程调用了start方法。这个时候线程的状态可能有很多种，但是我们通常认为线程在等待CPU的时间片时和已经获取时间片时处于这种状态。
        BLOCKED:线程在执行的时候遇见了互斥锁，并且互斥锁已经被其他线程获得，线程不得不等待其他线程释放锁才能获取CPU的时间片，在此锁未释放之前获取时间片都是无用的。
        WAITING：线程调用了等待的方法，它也不会获取时间片。这种状态必须由其它线程显示通知才能唤醒，从而才有获取时间片的基本条件。Object::wait()、Thread::join()、LockSupport::park()。
        TIMED_WAITING：线程调用了带时间参数的等待方法，它不会获取时间片，直到设置的时长之后或者被其他线程显示通知唤醒，此时才有获取时间片的基本条件。Thread::sleep(time)、Object::wait(time)、Thread::join(time)、LockSpport::parkNanos(time)、LockSpport::parkUntil(time)。
        TERMINATED：线程的执行逻辑执行完毕之后，线程的状态就会成为终止状态。
        关于BLOCKED和WAITING，一个原因是因为锁导致线程阻塞，一个是因为调用了等待的方法，通常是因为线程所需要才会主动去调用。

线程的停止

        线程正在执行的时候，贸然的去终止线程是不好的。因为线程在执行逻辑中，对数据的处理可能还没处理完毕，突然停止之后，就会造成数据的丢失或者脏数据等。因此线程的stop方法被标记为抛弃的方法。那如何让线程安全合理的停止呢？
        线程的设计之初就想到了这个问题，在线程中引入了中断机制，并且提供了相应的方法使我们在线程执行中引入一些操作。例如停止线程，但是其本质还是线程自己处理，其他线程只是可以通知而已。
        ①发出通知：使用线程实例调用线程的interrupt（）方法，该方法会将调用的线程实例的中断标志变为true。
        ②线程接收通知和响应：线程在执行过程中有两个方式来获取通知。第一种是自己在执行逻辑中进行中断标志的判断，并对收到通知做出响应。第二种是线程此时并不在执行，而是处于等待状态，这个时候，线程并没有获取时间片，不能及时的做出反应，因此中断异常机制很好的弥补了这一缺陷。在中断异常捕获的时候，我们可以做出一些对于事情响应的代码。
        注意：在线程被阻塞的时候，线程是没有办法做出响应的，而且阻塞的时候线程是不会抛出中断异常的，因此在通知一个可能被阻塞的线程中断的时候，需要考虑一下这些情况。

守护线程

        在一个线程A中，如果调用一个线程实例B的setDaemon（true）。那么这个线程实例所对应的线程B会成为线程A的守护线程。守护线程一般是用来做一些其余的辅助性工作，它不能做一些特殊的善后处理工作，因为当主线程A关闭的时候，辅助线程B也会关闭，不管其中的逻辑是否执行完成。因此注意，在程序中finally块的代码不一定会执行。

线程的优先级

        因为线程的实现还是根据不同的操作系统，而不同的操作系统中线程的优先级并不一样，因此不推荐使用线程的优先级来试图让某个线程获得更多的执行机会。

线程的构造函数

        线程一共有九种构造函数，分别有名字，Runnable，线程组，线程栈大小，访问控制上下文五个入参。线程除了在构造的时候传入线程的名称，还可以使用setName(name)方法后期修改线程的名称。如果我们对线程的名字不做处理的时候，线程会默认命名，规则是Thread-线程序号。线程序号是一个由jvm管理的全局递增的序号。

线程的常用API

sleep

        sleep有两个重载方法，一种传入毫秒数，一种继续要传入毫米数，也需要传入纳秒数。
        sleep方法，表示当前线程等待多长时间后继续执行。注意sleep并不会释放锁，但是在等待期间是不会获得时间片的。在JDK1.5之后引入了TimeUnit类，我们可以使用TimeUnit来代替sleep了。因为其表述比sleep清楚很多，如时分秒等。描述的比sleep的参数清晰很多。

yeild

        yeild方法，是一个食之无味，弃之可惜的方法。这个方法唯一的作用就是放弃当前时间片，但是它还会竞争时间片，因此这个机制是完全不可靠的，因此建议大家不要使用该方法。

getID

        getId是获取线程的序号，这个序号是由JVM管理依次递增的一个为线程设置的序号。

getName

        getName是获取线程名字，我们可以通过setName（name）来设置线程的名称,默认的名字是Thread-线程序号。

interrupt

        interrupt方法，是用来向调用实例发送一个中断信号。

interrupted

        interrupted是一个静态方法，它会返回当前线程的中断标志位，并且会对标志位进行清除。即调用后，中断标志位会被重置成false。

isInterrupted

        isInterrupted方法是一个实例方法，用于返回当前实例所代表的线程的中断标志位，它是不会将中断标志位进行清除的。

join

        join方法是一个实例方法，它的作用是，让调用线程串行在调用实例所代表的线程之后，例如在主线程中调用线程A实例的join方法，join后面的执行逻辑会等到线程A执行完成之后才会执行。join的本质一个wait方法。join的无参方法会调用join的join（0）方法。

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {//判断线程是否是终止状态，终止状态则不做处理
                wait(0);//线程活着则调用wait方法，阻塞当前线程
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

关于当前线程和线程实例

        我们代码运行的时候，一定是在某个线程中，因此我们创建线程的时候一定是在一个线程中创建其他的线程实例。我们会在线程中运行相应的业务处理，并且我们会在某个线程中调用其他的线程实例的实例方法。这个时候，我们只是在当前线程中运行代码，并不会对运行中的实例所代表的线程有任何影响，除非，在线程的逻辑处理中做了一些相应的处理。如join，调用方法的当前线程会被阻塞，因为相应的处理也是在当前线程，而不是线程实例所代表的线程。这一点在学习线程一定要弄清楚。