Java(二十三)——Java多线程

一、线程概述

几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

1.线程和进程

几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。
一般而言，进程包含如下三个特征：

• **独立性：**进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
• **动态性：**进程与程序的区别在于，程序知识一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。
• **并发性：**多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

注意：并发性（concurrency）和并行性（parallel）是两个概念。
并行指在同一时刻，有多条指令在多个处理器上同时执行；
并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

现代的操作系统都支持多进程的并发，但在具体的实现细节上可能因为硬件和操作系统的不同而采用不同的策略。比较常用的方式有：共用式的多任务操作策略，例如Windows3.1 和 Mac OS 9； 目前操作系统大多采用效率更高的抢占式多任务操作策略，例如Windows NT、Windows 2000以及UNIX/Linux等操作系统。

多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。**线程（Thread）**也被称作轻量级进程（Lightweight Process），线程是进程的执行单元。就像进程在操作系统中的地位一样，线程在程序中是独立的、并发的执行流。当进程被初始化后，主线程就被创建了。对于绝大多数的应用程序来说，通常仅要求有一个主线程，但也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程，每个线程也是相互独立的。
###2.多线程的优势
线程在程序中是独立的、并发的执行流，与分隔的进程相比，进程中线程之间的隔离程度要小。它们共享内存、文件句柄和其他每个进程应有的状态。
当操作系统创建一个进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源；但创建一个线程则简单得多，因此使用多线程来实现并发比使用多进程实现并发的性能要高得多。

总结起来，使用多线程编程具有如下几个有点：

• 进程之间不能共享内存，但线程之间共享内存非常容易。
• 系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。
• Java语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。

二、线程的创建和启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺序执行的代码）。Java使用线程执行体来代表这段程序流。

1.继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下：
1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体。
2.创建Thread子类的实例，即创建了线程对象。
3.调用线程对象的start()方法来启动该线程。

2.实现Runnable接口创建线程类

实现Runnable接口来创建并启动多线程的步骤如下：

• 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动该线程

3.使用Callable和Future创建线程

前面已经指出，通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程执行体。那么是否可以直接把任意方法都包装成线程执行体呢？Java目前不行！但Java的模仿者C#可以（C#可以把任意方法包装成线程执行体，包括有返回值的方法）。

也许受此启发，从Java 5开始，Java提供了Callable接口，该接口怎么看都像是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大。

• call()方法可以有返回值
• call()方法可以声明抛出异常
  因此完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是该Callable对象的call()方法。问题是：Callable接口是Java 5新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。而且call()方法还有一个返回值——call()方法并不是直接调用，它是作为线程执行体被调用的。那么如何获取call()方法的返回值呢？

Java 5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口——可以作为Thread类的target。

创建并启动有返回值的线程的步骤如下：

• 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建Callable实现类的实例。从Java 8开始，可以直接使用Lambda表达式创建Callable对象
• 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值
• 使用FutureTask对象作为Thread对象的target创建并启动新线程。
• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

4.创建线程的三种方式对比

采用实现Runnable、Callable接口的方式创建多线程的优缺点：

• 线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
• 在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
• 劣势是，编程稍稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

采用继承Thread类的方式创建多线程的优缺点：

• 劣势是，因为线程类已经继承了Thread类，所以不能再继承其他父类
• 优势是，编写简单，如果需要访问当前线程，则无须使用Thread.currentThread()方法，直接使用this即可获得当前线程

鉴于上面分析，因此一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。

三、线程的声明周期

当线程被创建并启动以后，它既不是已启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）5种状态。尤其是当线程启动以后，它不可能一直“霸占”着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。

1.新建和就绪状态

当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现成任何线程的动态特征，程序也不会执行线程的线程执行体。

当线程对象调用了start()方法之后，该线程就处于就绪状态，Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始执行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

注意
启动线程使用start()方法，而不是run()方法！永远不要调用线程对象的run()方法！调用start()方法来启动线程，系统会把该run()方法当成线程执行体来处理；但如果直接调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行——也就是说，如果直接调用线程对象的run()方法，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。

调用线程对象的start()方法之后，该线程立即进入就绪状态，但并未进入运行状态。如果希望调用子线程的start()方法后子线程立即开始执行，程序可以使用Thread.sleep(1)来让当前运行的线程（主线程）睡眠1毫秒。这样就可以让子线程立即开始执行。

2.运行和阻塞状态

如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态。
当发生如下情况时，线程将会进入阻塞状态

• 线程调用sleep()方法主动放弃所占用的处理器资源。
• 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞。
• 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。
• 线程在等待某个通知（notify）
• 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法。

被阻塞的线程会在合适的时候重新进入就绪状态，注意是就绪状态，而不是运行状态。

针对上面几种情况，当发生如下特定的情况时可以解除上面的阻塞，让该线程重新进入就绪状态。

• 调用sleep()方法的线程经过了指定时间
• 线程调用的阻塞式IO方法已经返回。
• 线程成功地获得了试图取得的同步监视器
• 线程正在等待某个通知时，其他线程发出了一个通知。
• 处于挂起状态的线程被调用了resume()恢复方法
  下图显示了线程状态转换图
  

3.线程死亡

线程会以如下三种方式结束，结束后处于死亡状态

• run()或call()方法执行完成，线程正常结束
• 线程抛出一个未捕获的Exception或Error
• 直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用。

注意
当主线程结束时，其他线程不受任何影响，并不会随之结束。一旦子线程启动起来后，它就拥有和主线程相同的地位，它不会受主线程的影响。

为了测试某个线程是否已经死亡，可以调用线程对象的isAlive()方法，当线程处于就绪、运行、阻塞三种状态时，该方法将返回true；当线程处于新建、死亡两种状态时，该方法将返回false。

四、控制线程

Java的线程支持提供了一些便捷的工具方法，通过这些便捷的工具方法可以很好地控制线程的执行。

1.join线程

Thread提供了一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完位置。

join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个问题分配一个线程。当所有小问题都得到处理后，再调用主线程来进一步操作。

join()方法有如下三种重载形式

• join():等待被join的线程执行完成。
• join(long millis):等待被join的线程的时间最长为millis毫秒。
• join(long millis, int nanos):等待被join的线程的时间最长为millis毫秒加namos毫微妙

2.后台线程

有一种线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为“后台线程（Daemon Thread）”，又称为“守护线程”或“精灵线程”。JVM的垃圾回收线程就是典型的后台线程。

后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。

调用Thread对象的setDaemon(true)方法可将指定线程设置成后台线程。但将某个线程设置为后台线程，必须在该线程启动之前设置。
Thread类还提供了一个isDaemon()方法，用于判断指定线程是否为后台线程。

3.线程睡眠：sleep

如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现。

4.线程让步：yield

yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。
实际上，当某个线程调用了yield()方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会。

关于sleep()方法和yield()方法的区别如下

• sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。
• sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而yield()不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用yield()方法暂停之后，立即再次获得处理器资源被执行。
• sleep()方法声明抛出了InterruptedException异常，所以调用sleep()方法时要么捕捉该异常，要么显式声明抛出该异常；而yield()方法则没有声明抛出任何异常。
• sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。

5.改变线程优先级

Thread类提供了setPriority(int newPriority)、getPriority()方法来设置和返回指定线程的优先级，其中setPriority()方法的参数可以是一个整数，范围是1~10之间，也可以使用Thread类的如下三个静态常量。

• MAX_PRIORITY：其值是10。
• MIN_PRIORITY：其值是1。
• NORM_PRIORITY：其值是5。

五、线程同步

当使用多个线程来访问同一个数据时，很容易“偶然”出现线程安全问题。不过即使程序偶然出现问题，那也是由于编程不当引起的。

1.线程安全问题

两个人使用同一账户并发取钱的问题。

2.同步代码块

为了解决同步安全性问题，Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。同步代码块的语法格式如下：

synchronized(obj)
{
	...
	// 此处的代码就是同步代码块
}

上面的obj就是同步监视器，上面代码的含义是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。

注意
任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。

虽然Java程序允许使用任何对象作为同步监视器，但想一下同步监视器的目的：阻止两个线程对同一个共享资源进行并发访问，因此通常推荐使用可能被并发访问的共享资源充当同步监视器。

3.同步方法

同步方法就是使用synchronized关键字来修饰某个方法，则该方法称为同步方法。对于synchronized修饰的实例方法（非static方法）而言，无须显式指定同步监视器，同步方法的同步监视器是this，也就是调用该方法的对象。

通过使用同步方法可以非常方便地实现线程安全的类，线程安全的类具有如下特征。

• 该类的对象可以被多个线程安全地访问。
• 每个线程调用该对象的任意方法之后都将得到正确结果。
• 每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。

注意
synchronized关键字可以修饰方法，可以修饰代码块，但不能修饰构造器、成员变量等。

可变类的线程安全是以降低程序的运行效率作为代价的，为了减少线程安全所带来的负面影响，程序可以采用如下策略。

• 不要对线程安全类的所有方法都进行同步，只对那些会改变竞争资源（竞争资源就是共享资源）的方法进行同步。
• 如果可变类有两种运行环境：单线程环境和多线程环境，则应该为该可变类提供两种版本，即线程不安全版本和线程安全版本。比如JDK所提供的StringBuilder、StringBuffer。

4.释放同步监视器的锁定

程序无法显式释放对同步监视器的锁定，线程会在如下几种情况下释放对同步监视器的锁定。

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

在如下所示的情况下，线程不会释放同步监视器。

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

5.同步锁（Lock）

从Java 5开始，Java提供了一种功能更强大的线程同步机制——通过显式定义同步锁对象来实现同步，在这种机制下，同步锁由Lock对象充当。
Lock提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock允许实现更灵活的结构，可以具有差别很大的属性，并且支持多个相关的Condition对象。
Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
某些锁可能允许对共享资源并发访问，如ReadWriteLock（读写锁），Lock、ReadWriteLock是Java 5提供的两个根接口，并为Lock提供了ReentrantLock（可重入锁）实现类，为ReadWriteLock提供了ReentranReadWriteLock实现类。
Java 8新增了新型的StampedLock类，在大多数场景中它可以替代传统的ReentranReadWriteLock。ReentranReadWriteLock为读写操作提供了三种锁模式：Writing、ReadingOptimistic、Reading。
在实现线程安全的控制中，比较常用的是ReentranLock（可重入锁）。使用该Lock对象可以显式地加锁、释放锁，通常使用ReentranLock的代码格式如下：

class X
{
	// 定义锁对象
	private final ReentranLock lock = new ReentranLock();
	//...
	// 定义需要保证线程安全的方法
	public void m()
	{ 
		// 加锁
		lock.lock();
		try
		{
			// 需要保证线程安全的代码
			// ...method body
		}
		// 使用finally块来保证释放锁
		finally
		{
			lock.unlock();
		}
	}
}

6.死锁

六、线程通信

1.传统的线程通信

wait():导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。
notify():唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该同步监视器的锁定后（使用wait()方法），才可以执行被唤醒的线程。
notifyAll():唤醒在此同步监视器上等待的所有线程。

2.使用Condition控制线程通信

如果程序不使用synchronized关键字来保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait()、notify()、notifyAll()方法进行线程通信了。
当使用Lock对象来保证同步时，Java提供了一个Condition类来保持协调，使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程。
Condition类提供了如下三个方法：

• await():类似于wait()方法
• signal():
• signalAll():