Java多线程基础知识（一）

摘要：多线程一线程模型实现线程有三种方式使用内核线程实现使用用户线程实现和使用用户线程加轻量级进程混合实现。这种轻量级进程与内核线程之间的关系称为一对一的线程模型。是通知所有等待对象控制权的线程继续运行。

实现线程有三种方式：使用内核线程实现、使用用户线程实现和使用用户线程加轻量级进程混合实现。内核线程是直接由操作系统内核支持的线程，通过内核完成线程切换，内核通过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。
程序不会直接使用内核线程，而是去使用内核线程的高级接口-轻量级进程。每个轻量级进程由一个内核线程支持。这种轻量级进程与内核线程之间1：1的关系称为一对一的线程模型。Sun JDK 的Windows版和Linux版都是使用一对一的线程模型，一条Java线程就映射到一条轻量级进程中。由于内核线程的支持，每个轻量级进程成为一个独立的调度单元，一个轻量级进程的阻塞不会影响整个进程。但也是因为基于内核线程实现，各种线程操作，如创建、析构及同步都要进行系统调用，需要在用户态和内核态中来回切换，调用代价高，其次轻量级进程消耗一定的内核资源，因此一个系统支持轻量级进程的数量有限。

线程调度是指系统为线程分配处理器使用权的过程，分为协同式调度和抢占式调度。协同式调度的多线程系统，线程执行时间由线程本身控制，线程完成自己的工作之后，主动通知系统切换到另一个线程上。优点是实现简单，切换操作是由线程主动的，对线程可知，没有线程同步问题。缺点是线程执行时间不可控制，如果一个线程阻塞，可能导致整个系统奔溃。抢占式调度的多线程系统，每个线程有系统分配执行时间，线程的切换不由线程本身决定。（yield可以让出执行时间，但线程本身无法获取执行时间）优点是线程执行时间系统可控。Java使用的线程调度方式就是抢占式调度。

Java线程的6种状态：

New（新建）

Runnable（可运行）

Blocked（阻塞）

Waiting（等待）

Timed waiting（限时等待）

Terminated（终止）

线程创建成功但尚未启动就是New；Runable状态的线程可能正在执行，也可能在等待CPU分配执行时间；当线程等待另一个线程通知调度器一个条件时就进入等待状态，例如Object.wait、Thread.join;当这些方法指定时间参数时就成了限时等待；当一个线程试图获取一个内部的对象锁，而该锁被另一线程持有时，该线程进入阻塞状态；当线程因run方法正常退出而自然死亡，或者因为没有捕获的异常死亡都会导致线程进入Terminated状态。

Java中断机制是一种协作机制，通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理中断。当对一个线程调用interrup方法时，线程的中断状态将被置位。这是每一个线程都具有的boolean标志位。每个线程都应该不时地检查这个标志，以判断线程是否被中断，并及时处理。

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
    interrupt0();
}

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
public boolean isInterrupted() {
    return isInterrupted(false);
}
private native boolean isInterrupted(boolean ClearInterrupted);

可以看到，interrupt方法通过设置中断位来完成中断。interrupted方法和isInterrupted方法都是通过调用native方法来检测中断的，interrupted是一个静态方法，用来检测当前线程是否被中断，而且interrupted会清除该线程的中断状态；isInterrupted是一个实例方法，可用来检验是否有线程被中断，该方法不会改变中断状态。

一般来说，我们中断线程的目的很可能是想停止线程执行。怎么停止线程执行呢？我们可以在判断中断置位后，用return退出run方法。但这样设计并不优雅，另外一种方式，就是抛出InterruptedException并在run方法里捕获。捕获后怎么处理也是件值得考虑的事，最好的方法是直接抛给调用者处理，但run方法是重写方法，结构已固定，无法抛出异常，我们还可以在捕获InterruptedException后重新中断当前线程，让调用者检测。

wait方法是挂起当前线程，释放当前对象的控制权（释放锁），然后线程处于等待状态。notify是通知正在等待对象控制权（锁）的线程可以继续运行。notifyAll是通知所有等待对象控制权的线程继续运行。这几个方法是基于monitor监视器锁来实现的，所以必须在同步块内执行。

sleep让当前线程暂停指定时间。wait方法依赖于同步，sleep可以直接调用。因为sleep只是暂时让出CPU的执行权，并不释放锁，而wait需要释放锁。举个简单的例子：

public class WaitTest {
    private static Object o = new Object();
    
    static class Thread1 extends Thread{

        @Override
        public void run() {
            try {
                synchronized(o){
                    System.out.println("Thread1--start");
                    //o.wait();
                    Thread.sleep(2000);
                    System.out.println("Thread1--end");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("a");
            }
        }
    }
    
    static class Thread2 extends Thread{

        @Override
        public void run() {
            synchronized(o){
                System.out.println("Thread2--start");
                o.notify();
                System.out.println("Thread2--end");
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException{
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        t1.start();
        Thread.sleep(100);//保证t1先获得锁
        t2.start();
    }
}

在线程1里分别调用sleep和wait会有不同的结果，调用sleep时线程1不会释放锁，所以会打印完“Thread1 start”、“Thread1 end”，再进入线程2的打印。调用wait时，打印完“Thread1-start”，就会释放锁，这时线程2的打印得以继续进行，会打印“Thread2 start”。

Thread.yield()方法会将当前线程从Running转为Runnable，让出当前对进程的使用，以便其他线程有机会执行，不过调度器可以忽虐该方法，也不能指定暂停时间，一般只用来调试和测试。

Thread.join()方法用于将异步的线程“合并”为同步的线程，父线程等待子线程执行完成后再执行。其实并不算合并，而是调用join的线程进入限时等待，不断检查子线程状态，在子线程执行完成后恢复执行。看一下它的实现原理：

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);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

可以看到，join是通过子线程不断轮询自己状态一直到执行完毕才返回继续执行父线程。

在Java中，最基本的互斥同步手段就是synchronized关键字，synchronized自动提供一个锁以及相关的条件。synchronized同步块对于同一条线程来说是可重入的，其次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。前面提到，Java的线程是映射到系统原生线程上，阻塞或唤醒一个线程，都需要操作系统帮忙完成，需要从用户态转为核心态，这需要耗费很长时间。因此synchronized是重量级操作，虚拟机本身会有一些优化手段，比如在阻塞之前加入自旋等待过程，避免频繁切入核心态之中。

重入锁（ReentrantLock）与synchronized相似，具备一样的线程重入性，一个表现为API层面的互斥锁，另一个表现为原生语法层面的互斥锁。ReetrantLock增加了一些功能：等待可中断、公平锁和锁绑定多个条件。

公平锁是指多个线程等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁，可以通过带布尔值的构造函数要求使用公平锁。

 /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

等待可中断是指持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTestOne {
    static int count = 0;
    static ReentrantLock lock = new ReentrantLock();
    
    public static void main(String[] args) throws Exception{
        Thread a = new Thread(new CountThread("a"));
        Thread b = new Thread(new CountThread("b"));
        a.start();
        Thread.sleep(100);//确保b线程后执行，a能先获得锁
        b.start();
        Thread.sleep(500);//等待0.5s后，a线程还没有释放锁，通过中断放弃等待
        b.interrupt();
    }
    
    static class CountThread extends Thread{
        
        String name;

        CountThread(String name){
            this.name = name;
        }
                
        @Override
        public void run() {
            /*try{
                lock.lockInterruptibly();
            }catch(InterruptedException e){
                System.out.println("Thread "+name+" interrupted");
                return;
            }*/
            lock.lock();
            System.out.println(Thread.currentThread().isInterrupted());
            try{
                System.out.println("Thread "+name+" begin");
                for(int i=0; i<2000000; i++){
                    for(int j=0; j<100000; j++){
                        count++;
                    }
                }
                System.out.println("Thread "+name+" end");
            }finally{
                lock.unlock();
            }
        }
    }
}

我们先看lock.lock的执行结果：

可以看见a线程执行完后b才开始执行，且b线程的中断位已被置位。说明lock是阻塞式的获取锁，只有在成功获取到锁以后才处理中断信息，并且怎么处理由调用端决定，lock只负责给中断位置位。
再看一下lock.lockInterruptibly的执行结果：

可以看到，lockInterruptibly会立即处理中断信息，抛出InterruptedException，而不用等到获取锁。

锁绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象。在synchronized中，锁对象的wait和notify其实实现一个隐含的条件，如果要和多个条件关联，必须额外添加锁。

public class ReentrantLockTestTwo {
    
    static ReentrantLock lock = new ReentrantLock();
    
    static Condition productCondition = lock.newCondition();
    static Condition customerCondition = lock.newCondition();
    
    static Set