Java线程基础

线程状态

在Thread.java类文件中，有一个state静态枚举内部类，预定义了Thread的状态。

BLOCKED&WAITING

在文档中介绍，BOLCKED状态主要指多线程程序运行时，多个线程进入临界区，线程互相排斥，等待锁的获取与释放。而WAITING泛指处于等待状态的线程等待另一个线程去执行任务。

WAITING状态是因为Object.wait()，Thread.join()等方法(无参重载方法，不需要指定时间)造成的。而BLOCKED主要是因为同步中锁的获取与释放以及IO流阻塞方法。

WAITING&TIMED_WAITING

WAITING与TIMED_WAITHING的区别在于WAITING需要手动唤醒，例如调用Object.notify()/Object.notifyAll()；而TIMED_WAITING状态是线程等待一定的时间。

造成TIMED_WAITING状态的原因可能是调用了以下方法：

• Thread.sleep()
• Object.wait()的指定时间重载方法
• Thread.join()的指定时间重载方法
• 等等

jstack

使用JDK内置工具jstack可以查看线程处于什么状态。一般的jstack查看命令jstack pid。而pid是指Java虚拟机的进程id，可以通过jps命令来查看。

了解了线程状态，以及他们的原因和解决办法，遇到问题时就有头绪解决。例如线程处于阻塞状态，可能是因为临界区的锁没有释放等。

更多JDK内置工具可以参考 jstack命令(Java Stack Trace)

参考

Java线程状态分析

Lock

一般实现同步，都是给代码临界区加上synchronized，变成同步语句或同步方法。这样保证线程排斥，同一时刻只允许一个线程进入代码临界区。实际上，执行同步方法或语句之前，线程隐式的给实例（或类）加了一个锁。在Java中可以显示加锁。

锁的作用

Lock实际上创建的是相互排斥的锁。当线程执行临界区时，首先通过lock.lock()获取锁，执行完毕后通过lock.unlock()释放锁，让其他获取到锁的线程有机会执行。由于是排斥的锁，所以同一时刻只有一个线程可以进入代码临界区。

代码编写过程中，一般使用try-finally，在finally块中释放锁。

线程协作

由于线程的调度完全由CPU分配(线程共享CPU时间切片)，导致程序无法按照开发人员设计运行。所以线程之间的协作尤为重要。

可以通过Lock.newCondition()创建一个条件对象(Condition)。线程间的协作需要通信，通过Condition对象线程间相互通信，指定线程在条件下该做何种操作。

创建条件实例后，可以通过以下方法实现线程通信：

• await()，使线程进入WAITING状态，直到执行条件发生，通过手动唤醒；
• signal()，条件满足，唤醒该条件等待的一条线程；
• signalAll()，条件满足，唤醒该条件等待的所有线程。

注意，使用条件的方法前，必须已经获取了锁，否则会抛出异常。使用await()进入等待的线程，必须使用唤醒方法，否则一直处于等待(WAITING)状态。

await()，可以让当前锁定临界区的线程释放该条件的锁，允许其他线程进入。而且当使用signal()/signalAll()唤醒等待线程后，执行先前使用await()的下一行代码。

监视器

锁和条件都是Java 5中新增的内容，在此之前，线程之间的通信是通过对象内置的监视器编程实现的。

监视器是一个相互排斥且具备同步能力的对象。监视器中的一个时间点上，只能有一个线程执行一个方法。

线程通过获取监视器上的锁进入监视器，并且通过释放锁退出监视器。而这个锁是通过线程执行synchronized方法块或方法来获取的。也就是说监视器对象可以是任意对象，但必须是synchronized锁住的对象。

通过调用监视器对象的wait()来释放锁并且进入等待状态，让监视器对象中的其它线程有机会执行任务；当条件合适时，另一个线程中调用监视器的notify()/notifyAll()来通知一个或所有等待线程重新获取锁并且恢复执行。

当监视器调用wait()时，阻塞当前线程，并且释放锁。当监视器调用notify()/notifyAll()时，通知该线程启动，并且可以获取锁。

Object的wait()、notify()、notifyAll()类似于Condition的await()、signal()、signalAll()。

死锁

又是两个线程或多个线程需要在几个共享对象上获取锁，这就有可能导致死锁。

例如，线程a获取了对象A的锁，并且在等待对象B的锁；而此时线程b获取了对象B的锁，在等待对象A的锁。这样一来线程a，b都无法获取到需要的锁继续执行任务(没有线程释放所需的锁)，导致死锁。

解决办法是通过资源排序技术。该技术指定给对象上锁顺序，避免死锁。

例如指定对象A，B上锁的顺序必须是A在前，那么线程a，b就不会死锁，因为线程b必须先获取对象A的锁才可以获取对象B的锁，否则一直处于BLOCKED。

一个线程从一个共享对象获取锁后，此时有另一个线程获取该对象的锁时，由于锁的互斥，第二个线程无法执行。

中断线程

终止线程有两个原因：

• 线程的run()执行到最后一条语句，并执行return语句返回时，自然终止；
• 线程的run()执行时遇到一个没有捕获的异常意外终止。

没有可以强制终止线程的方法（stop()被废弃），但是可以使用interrupt()来请求终止线程，当调用它时，线程的中断状态被置位。这是每一个线程都有一个boolean标志位，且应该不时地去检查这个标志位，以判断线程是否被中断。

没有强制线程终止的方法，但是通过interrupt()方法，可以将中断状态标志位置位，然后去检查它，来判断线程是否被中断（实际上线程未终止，可以根据标志位去执行特定的操作）。

当一个线程在调用interrupt()后，被置于阻塞状态(阻塞调用后进入阻塞状态，sleep或wait等方法的执行)，就会抛出InterruptedException异常，中断阻塞调用。

线程的中断非终止。任何语言都没有需求要求一个被中断的线程应该被终止（置线程于TERMINATED状态）。

中断线程是引起线程的注意，被中断的线程决定如何响应中断，保证了线程在安全的时候停止。普遍的处理是线程将中断作为一个终止请求。

public void run() {
    try {
        ...
        while(!Thread.currentThread().isInterrupted()  //check interrput boolean
            && more work to do) {
            do more work
        }
    }catch(InterruptedException) {
        //Thread was interrupted during sleep or wait
    }finally {
        cleanup,if required //do something for terminated
    }
    //exiting the run method terminates the thread
}

中断方法

• void interrupt()，请求中断，中断标志位置位。
• static boolean interrupted()，静态方法，检测当前线程是否被中断(其实代码就是检测中断标志位)，且清楚该线程的中断标志位值。如果被中断，返回TRUE，否则返回FALSE。
• boolean isInterrupted()，用来检测是否有线程被中断，但是不会清楚中断状态。如果被中断，返回TRUE，否则返回FALSE。

GUI线程

Java的GUI事件处理和绘制任务在一个event dispatch thread中执行。这是因为大多数GUI方法都是非线程安全的，如果从多线程中执行这些任务会造成冲突。

线程安全，如果一段代码在多线程程序中没有导致竞争状态，则称这样的代码是线程安全的。

可以通过javax.swing.Utilities类中的静态方法，在event dispatch thread中执行任务。

• Utilities.invokeLater()，该方法无须等待任务执行完毕就返回。
• Utilities.invokeAndWait()，该方法必须等待任务执行完毕后返回，导致方法阻塞。

信号量

信号量可以用来限制访问共享资源的线程数量。在访问资源之前，线程从信号量获取许可，此时总的许可减一；在访问完资源后，线程必须把许可释放还给信号量。

当信号量的许可总数为1时，可以实现同步。

Thread.sleep()&Object.wait()

在以前的JDK版本中还有一个suspend()实例方法，用于阻塞线程。但是它极其容易导致死锁，拥有锁的线程被挂起后，在恢复之前(resume())无法释放锁。如果一个线程调用另一个线程suspend()，且该线程需要获取同一个锁时，就造成了死锁。

Thread.sleep()也不会释放锁，直接阻塞线程。但是由于它是静态方法，所以阻塞的是当前线程，不会造成死锁。

Condition、监视器的阻塞线程的方法可以释放锁，当等待中的线程被唤醒时又有机会重新获取锁。

所以他们的主要区别有：

1. 它们来自不同的类，同时sleep()属于静态方法，使当前线程进入TIMED_WAITING。
2. sleep()不会释放锁，而wait()会。
3. sleep()可以在线程中的任意地方调用，而wait()必须在同步方法或同步语句中调用。
4. sleep()必须捕获InterruptedExpection，而wait()不需要。

锁的可重入

锁的可重入是指，当一个线程试图请求获取已经持有的锁时，这个请求可以成功。重入的一个重要作用是防止死锁：

public class Father {
    public synchronized void doSomething(){ ......
    } 
}

public class Child extends Father {
    public synchronized void doSomething(){ ......
        super.doSomething(); 
    }
}

当一个线程调用Child实例的doSomething()时，首先请求获取该实例的锁，在执行super.doSomething()时再次请求获取实例的锁。

如果没有重入，当调用super.doSomething()时无法再次获取Child实例锁，线程会一直阻塞下去，造成死锁。而锁的重入就避免了这种死锁。

但是当退出super.soSomething()时，线程并未释放锁，只有退出Child实例的doSomething()时，才会释放锁，让其他线程进入。