Java基础：多线程1-优快云博客

2019独角兽企业重金招聘Python工程师标准>>>

1 线程生命周期

JDK中，线程状态定义在java.lang.Thread类的内部枚举类State中：

java.lang.Thread.State源码：

public enum State {

//至今尚未启动的线程

NEW,

//可运行或正在运行的线程

RUNNABLE,

//受阻塞并等待某个同步监视器锁的线程

BLOCKED,

//无限期地等待另一个线程来执行某一特定操作的线程

WAITING,

//指定等待时间,等待另一个线程来执行某一特定操作的线程

TIMED_WAITING,

//已结束的线程

TERMINATED;

}

线程状态具体转换图：

创建状态 (New Thread)

在 Java 语言中使用 new 操作符创建一个线程后，该线程仅仅是一个空对象，它具备了线程的一些特征，但此时系统没有为其分配资源，这时的线程处于创建状态。

就绪状态 (Runnable)

使用 start() 方法启动一个线程后，系统为该线程分配了除 CPU 外的所需资源，使该线程处于就绪状态。此外，如果某个线程执行了 yield() 方法，那么该线程会被暂时剥夺 CPU 资源，重新进入就绪状态。

运行状态 (Running)

Java 运行系统通过调度选中一个处于就绪状态的线程，使其占有 CPU 并转为运行状态。此时，系统真正执行线程的 run() 方法。

阻塞状态 (Blocked)

一个正在运行的线程因某些原因不能继续运行时，它就进入阻塞状态。

原因包括：

当执行了某个线程对象的 suspend()、sleep() 等阻塞类型的方法时，该线程对象会被置入一个阻塞集（Blocked Pool）内，等待被唤醒（执行 resume() 方法）或是因为超时而时自动苏醒；
当多个线程试图进入某个同步区域（synchronized）时，没能进入该同步区域的线程会被置入等待集（Wait Pool），直到获得该同步区域的锁，进入就绪状态；

死亡状态 (Dead)

线程在 run() 方法执行结束后进入死亡状态。此外，如果线程执行了 interrupt() 或 stop() 方法，那么它也会以异常退出的方式进入死亡状态。

2 经典线程

2.1 线程的创建和启动

2.1.1 Thread

public class MyThread extends Thread {

private int i;

public void run() {

for (; i < 100; i++) {

System.out.println(this.getName() + " " + i);

}

public static void main(String[] args) {

for (int i = 0; i < 100; i++) {

System.out.println(Thread.currentThread().getName() + " " + i);

if (i == 20) {

new MyThread().start();

}

2.1.2 Runnable

public class MyThread implements Runnable {

private int i;

public void run() {

for (; i < 100; i++) {

// 当线程类实现Runnable接口时

// 如果想获取当前线程，只能用Thread.currentThread()方法

System.out.println(Thread.currentThread().getName() + " " + i);

}

public static void main(String[] args) {

for (int i = 0; i < 100; i++) {

System.out.println(Thread.currentThread().getName() + " " + i);

if (i == 20) {

MyThread mt = new MyThread();

new Thread(mt, "新线程1").start();

new Thread(mt, "新线程2").start();

}

2.1.3 Thread VS Runnable

Runnable：

线程类只是实现了Runnable接口，还可以继承其他类；

多个线程可以共享同一个Runnable对象，所以非常适合多个相同线程处理同一份资源的情况。从而可以将CPU，代码和数据分开，形成清晰的模型。

如果需要访问当前线程，则必须使用Thread.currentThread( )方法

Thread:

线程类已经继承了Thread，不能再继承其他父类。

如果需要访问当前线程，无须使用Thread.currentThread( )方法，直接使用this即可。

鉴于上面的对比，一般推荐采用Runnable接口来创建多线程。

2.2 控制线程

Thread类源码里主要提供了如下几个方法：

join()：让一个线程等待另一个线程完成。

当在某个程序执行流中调用其他线程的join（）方法时，调用线程将被阻塞，直到被join方法加入的join线程执行完为止。

sleep(long millis)：让当前正在执行的线程暂停一段时间，并进入阻塞状态。

yield()：让当前正在执行的线程暂停，但是它不会阻塞该线程，它只是将该线程转入就绪状态。

getId():获取线程的ID

setName(String)：设置线程的名称

getName()：获取线程名称

getState()：获取线程的状态

setPriority(int)：设置线程的优先级，范围是1~10之间，也可以使用Thread类的3个静态常量：MAX_PRIORITY，MIN_PRIORITY,NORM_PRIORITY。

getPriority()：返回线程的优先级

setDaemon(boolean)：设置线程为后台线程。后台线程为其他线程提供服务，例如JVM的垃圾回收线程。如果所有的前台线程都死亡，后台线程会自动死亡。

isDaemon（）：判断某个线程是否后台线程。

‍2.3 线程同步‍

Java中，每一个对象（包括实例和Class对象）内部都有一个同步监控器，与synchronized关键字、wait()、notify（）和notifyAll（）方法配合，实现线程同步。

2.3.1 比喻

事物：

一个对象就像一个大房子，大门永远打开。房子里有很多房间（也就是方法），这些房间有的上锁（synchronized方法），有的不上锁（普通方法）。房子里有且只有一把钥匙（即同步监视器），这把钥匙可以打开所有上锁的房间。所有想调用该对象方法的线程比喻成想进入这房子某个房间的人。

规则：

没上锁的房间，可以随时进入。

上锁的房间，要获取钥匙后，才能进入，如果钥匙正被其他人使用，则自己站到等待队列里。

使用完一间上锁房间，需要将钥匙立刻归还。如果还需要用钥匙，再排队取钥匙。

情景：

1：张三需要上锁房间，李四需要不上锁房间。那么张三获取钥匙，进入上锁房间，李四直接进入不上锁房间，两者互不影响。

2：张三需要上锁房间，李四需要上锁房间（包括”李四和张三去的是同一个上锁房间“、”李四和张三去的不是同一个上锁房间“）。那么张三李四竞争去获取钥匙，谁获取钥匙，谁进入房间，另外一个人等待钥匙。

3：张三需要上锁房间，并且获取钥匙进入房间，李四阻塞等待钥匙。张三在上锁房间内调用了sleep（），睡着了。钥匙仍在张三身上，直到张三醒来，处理完事情。李四仍需要等待。

4：张三在上锁房间里，碰到了房子的wait（）函数，张三只能将钥匙归还并到wait pool里等待通知。

5：张三在上锁房间里，碰到了房子的notify（）函数或notifyAll（）函数，张三归还钥匙后，通知wait pool里的某个人或所有人去抢钥匙。

2.3.2 synchronized方法和synchronized块

synchronized(obj){

.......

}

synchronized后括号里的obj就是同步监视器。线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。任何时候只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。

与同步代码块对应，java的多线程安全还支持同步方法，同步方法就是使用synchronized关键字来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无须显式指定同步监视器，同步方法的同步监视器是this，也就是该对象本身。

synchronized关键字可以修饰方法，可以修饰代码块，但不能修饰构造器、属性等。

2.3.3 释放同步监视器的锁定

任何线程进入同步代码块、同步方法之前，必须先获得对同步监视器的锁定，那么何时会释放对同步监控器的锁定呢？程序无法显式释放对同步监控器的锁定，线程会在如下几种情况下释放对同步监视器的锁定：

当前线程的同步方法、同步代码块正常执行结束，当前线程即释放同步监视器。
当前线程在同步方法、同步代码块中遇到break，renturn终止了代码块、方法的继续执行，当前线程会释放同步监视器。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致该代码块、方法异常结束时，当前线程释放同步监视器。
当前线程执行同步代码块、同步方法时，执行了同步监视器对象的wait（）方法，则当前线程暂停，并释放同步监视器。

线程不会释放同步监视器的情况如下：

当前线程执行同步代码块、同步方法时，程序调用了Thread.sleep（）、Thread.yield( )方法来暂停当前线程的执行，当前线程不会释放同步监视器。
当前线程执行同步代码块、同步方法时，其他线程调用了该线程的suspend（）方法，将该线程挂起，该线程不会释放同步监视器。当然，我们应该尽量避免使用suspend（）和resume（）方法来控制线程。

2.3.4 示例

http://www.oschina.net/code/snippet_820500_44794

3 java.util.concurrent包

3.1 阻塞队列

3.1.1 什么是阻塞队列

Java 5提供了一个BlockingQueue接口，虽然BlockingQueue也是Queue的子接口，但它的主要用途并不是作为容器，而是作为线程同步的工具。BlockingQueue具有一个特性：当生产者试图向BlockingQueue中放入元素时，如果该队列已满，则该线程被阻塞；当消费者试图从BlockingQueue中取元素时，如果该队列已空，则该线程被阻塞。

BlockingQueue提供如下两个支持阻塞的方法：

put（E e）：尝试把E元素放入BlockingQueue中，如果该队列的元素已满，则阻塞该线程。

take（）：尝试从BlockingQueue的头部取出元素，如果该队列的元素已空，则阻塞该线程。

3.1.2 实现类

ArrayBlockingQueue：基于数组实现的BlockingQueue。

LinkedBlockingQueue：基于链表实现的BlockingQueue。

SynchronousQueue：同步队列。对该队列的存、取操作必须交替进行。

3.1.3 示例

public static void main(String[] args) throws InterruptedException {

BlockingQueue bqueue = new ArrayBlockingQueue(20);

for (int i = 0; i < 30; i++) {

// 将指定元素添加到此队列中，如果没有可用空间，将一直等待（如果有必要）。

bqueue.put(i);

System.out.println("向阻塞队列中添加了元素:" + i);

}

System.out.println("程序到此运行结束，即将退出----");

}

输出结果：

向阻塞队列中添加了元素:0

向阻塞队列中添加了元素:1

向阻塞队列中添加了元素:2

.....

向阻塞队列中添加了元素:18

向阻塞队列中添加了元素:19

可以看出，输出到元素19时候，就一直处于等待状态，因为队列满了，程序阻塞了。

3.2 线程的创建和启动

3.2.1 Future、Callable

public interface Callable<V> {

V call() throws Exception;

}

public interface Future<V> {

boolean cancel(boolean mayInterruptIfRunning);

boolean isCancelled();

boolean isDone();

V get() throws InterruptedException, ExecutionException;

V get(long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException;

}

Runnable接口里的run()方法不能返回值和抛出异常，JDK 5添加了Callable接口作为Runnable接口的增强版，Callable接口提供了一个call（）方法作为线程执行体，call（）方法可以有返回值，可以声明抛出异常。

Callable接口有泛型限制，Callable接口里的泛型参数类型与call（）方法返回值相同。

线程执行完，如何获取Call（）方法的返回值呢？

JDK 5提供了Future接口代表Callable接口里call（）方法的返回值。

因为Thread类只能接受Runnable接口作为执行目标，但线程池支持Callable接口作为执行目标，所以要使用Callable和Future接口完成线程，需要使用线程池。

示例：

public class MyCallThread implements Callable<String> {

@Override

public String call() throws Exception {

return "hello world";

}

public static void main(String[] args) {

// 新建线程池

ExecutorService es = Executors.newSingleThreadExecutor();

// 将Callable接口实现类的对象作为submit（）函数的参数

// /submit（）函数返回值为Future

Future<String> result = es.submit(new MyCallThread());

try {

// 通过Future的get（）方法获取Callable的call（）方法的返回值

String str = result.get();

System.out.println(str);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

运行结果：

1	`hello world`

3.2.2 FutureTask

对于Callable和Future，除了使用线程池外，JDK还提供了一个FutureTask类，用于整合Callable和Future。

FutureTask类实现了Runnable接口和Future接口，并提供了两个构造函数：

1 2	`public` `FutureTask(Callable<V> callable) {}` `public` `FutureTask(Runnable runnable, V result) {`

因为FutureTask实现了Runnable接口，所以可以作为Thread类的目标执行类。

FutureTask的使用步骤：

创建Callable接口的实现类，并实现call（）方法，该call（）方法作为线程执行体，且call（）方法有返回值。
创建Callable实现类的对象，使用FutureTask类封装Callable对象，该FutureTask对象封装了该Callable对象的call（）方法返回值。
使用FutureTask对象作为Thread对象的target创建并启动新线程。
调用FutureTask对象的get（）方法获取线程执行结束后的返回值。

示例：