博文正文开头格式：（2分）
| 项目html |
内容java |
| 这个做业属于哪一个课程程序员 |
https://www.cnblogs.com/nwnu-daizh算法 |
| 这个做业的要求在哪里数据库 |
https://www.cnblogs.com/nwnu-daizh/p/12031970.html编程 |
|
做业学习目标canvas |
(1) 掌握Java应用程序的打包操做；数组 (2) 掌握线程概念；缓存 (3) 掌握线程建立的两种技术。安全 (4)学习应用程序的GUI |
本章内容：
14.1 什么是线程
Thread 类的静态 sleep 方法将暂停给定的毫秒数。调用 Thread.sleep 不会建立一个新线程， sleep 是 Thread 类的静态方法，用于暂停当前线程的活动。 sleep 方法能够抛出一个 InterruptedException 异常。
java.lang.Thread 1.0
static void sleep(long millis)
休眠给定的毫秒数。
参数：millis 休眠的毫秒数
不要调用 Thread 类或 Runnable 对象的 run 方法。直接调用 run 方法，只会执行同一个线程中的任务，并不会启动新线程。应该调用 Thread.start 方法。这个方法将建立一个执行 run 方法的新线程。
java.lang.Thread 1.0
Thread(Runnable target)
构造一个新线程，用于调用给定target的run()方法。
void start()
启动这个线程，将引起调用run()方法。这个方法将当即返回，而且新线程将并行运行。
void run()
调用关联Runnable的run方法。
java.lang.Runnable 1.0
void run()
必须覆盖这个方法，并在这个方法中提供所要执行的任务指令。
14.2 中断线程
当线程的 run 方法执行方法体重最后一条语句后，并经由执行 return 语句返回时，或者出现了在方法中没有捕获的异常时，线程将终止。在Java的早期版本中，还有一个 stop 方法，其余线程能够调用它终止线程。可是，这个方法如今已经被弃用了。
有一种能够强制线程终止的方法。然而， interrupt 方法能够用来请求终止线程。
当对一个线程调用 interrupt 方法时，线程的中断状态将被置位。这是每个线程都具备的 boolean 标志。每一个线程都应该不时地检查这个标志，以判断线程是否被中断。
调用 Thread.currentThread().isInterrputed() 方法得到当前线程的中断状态是否被置位。可是，若是线程被阻塞，就没法检测中断状态。这是产生 InterruptedException 异常的地方。当在一个被阻塞的线程（调用 sleep 或 wait ）上调用 interrupt 方法时，阻塞调用将会被 Interrupt Exception 异常中断（存在不能被中断的阻塞 I/O 调用，应该考虑选择可中断的调用）。
没有任何语言方面的需求要求一个被中断的线程应该终止。中断一个线程不过是引发它的注意。被中断的线程能够决定如何响应中断。某些线程是如此重要以致于应该处理完异常后，继续执行，而不理会中断。可是，更普通的状况是，线程将简单地将中断做为一个终止的请求。
若是在每次工做迭代以后都调用 sleep 方法（或者其余的可中断方法）， isInterrpted 检测既没有必要也没有用处。若是在种蒜状态被置位时调用 sleep 方法，它不会休眠。相反，它将清除这一状态（！）并抛出 InterrputedException 。所以，若是你的循环调用 sleep ，不会检测中断状态，相反，须要捕获 InterrputedException 异常。
有两个很是相似的方法， interrupted 和 isInterrupted 。 Interrupted 方法是一个静态方法，它检测当前的线程是否被中断。并且，调用 interrupted 方法会清除该线程的中断状态。另外一方面， isInterrupted 方法是一个实例方法，可用来检验是否有线程被中断。调用这个方法不会改变中断状态。
java.lang.Thread 1.0
void interrupt()
向线程发送中断请求。线程的中断状态将设置为 true 。若是目前该线程被一个 sleep 调用阻塞，那么， InterruptedException 异常被抛出。
static boolean interrupted()
测试当前线程（即正在执行这一命令的线程）是否被中断。注意，这是一个静态方法。这一调用会产生反作用-它将当前线程的中断状态重置为false。
boolean isInterrupted()
测试线程是否被终止。不像静态的中断方法，这一调用不改变线程的中断状态。
static Thread currentThread()
返回表明当前执行线程的 Thread 对象。
14.3 线程状态
线程能够有以下6种状态：
New (新建立)
Runnable (可运行)
Blocked (被阻塞)
Waiting (等待)
Timed waiting (计时等待)
Terminated (被终止)
14.3.1 新建立线程
当用new操做符建立一个新线程，如 new Thread(r) ，该线程尚未开始运行。这意味着它的状态是 new 。当一个线程处于新建立状态时，程序尚未开始运行线程中的代码。在线程运行以前还有一些基本工做要作。
14.3.2 可运行线程
一旦调用 start 方法，线程处于 runnable 状态。一个可运行的线程可能正在运行也可能没有运行，这取决于操做系统给线程提供运行的时间。（ Java 的规范说明没有将它做为一个单独状态。一个正在运行中的线程仍然处于可运行状态。）
一旦一个线程开始运行，它没必要始终保持运行。事实上，运行中的线程被中断，目的是为了让其余线程得到运行机会。线程调度的细节依赖于操做系统提供的服务。抢占式调度系统给每个可运行线程一个时间片来执行任务。当时间片用完，操做系统剥夺该线程的运行权，并给另外一个线程运行机会。当选择下一个线程时，操做系统考虑线程的优先级。
在任何给定时刻，一个可运行的线程可能正在运行也可能没有运行（这就是为何将这个状态称为可运行而不是运行）。
14.3.3 被阻塞线程和等待线程
当线程处于被阻塞或等待状态时，它暂时不活动。它不运行任何代码且消耗最少资源。直到线程调度器从新激活它。细节取决于它是怎样达到非活动状态的。
当一个线程试图获取一个内部的对象锁（而不是 java.util.concurrect 库中的锁），而该锁被其余线程持有，则该线程进入阻塞状态。当全部其余线程释放该锁，而且线程调度器容许本线程持有它的时候，该线程将变成非阻塞状态。
当线程等待另外一个线程通知调度器一个条件时，它本身进入等待状态。在调用 Object.wait 方法或 Thread.join 方法，或者是等待 java.util.concurrent 库中的 Lock 或 Condition 时，就会出现这种状况。实际上，被阻塞状态与等待状态是由很大不一样的。
有几个方法有一个超时参数。调用它们致使线程进入计时等待（ timed waiting ）状态。这一状态将一直保持到超时期满或者接收到适当的通知。带有超时参数的方法有 Thread.sleep 和 Object.wait 、 Thread.join 、 Lock.tryLock 以及 Condition.awit 的计时版。
当一个线程被阻塞或等待时（或终止时），另外一个线程被调度为运行状态。当一个线程被从新激活（例如，由于超时期满或成功地得到一个锁），调度器检查它是否具备比当前运行线程更高的优先级。若是是这样，调度器从当前运行线程中挑选一个，剥夺其运行权，选择一个新的线程运行。
线程状态图
Thread 类的静态 sleep 方法将暂停给定的毫秒数。调用 Thread.sleep 不会建立一个新线程， sleep 是 Thread 类的静态方法，用于暂停当前线程的活动。 sleep 方法能够抛出一个 InterruptedException 异常。
java.lang.Thread 1.0
static void sleep(long millis)
休眠给定的毫秒数。
参数：millis 休眠的毫秒数
不要调用 Thread 类或 Runnable 对象的 run 方法。直接调用 run 方法，只会执行同一个线程中的任务，并不会启动新线程。应该调用 Thread.start 方法。这个方法将建立一个执行 run 方法的新线程。
java.lang.Thread 1.0
Thread(Runnable target)
构造一个新线程，用于调用给定target的run()方法。
void start()
启动这个线程，将引起调用run()方法。这个方法将当即返回，而且新线程将并行运行。
void run()
调用关联Runnable的run方法。
java.lang.Runnable 1.0
void run()
必须覆盖这个方法，并在这个方法中提供所要执行的任务指令。
14.2 中断线程
当线程的 run 方法执行方法体重最后一条语句后，并经由执行 return 语句返回时，或者出现了在方法中没有捕获的异常时，线程将终止。在Java的早期版本中，还有一个 stop 方法，其余线程能够调用它终止线程。可是，这个方法如今已经被弃用了。
有一种能够强制线程终止的方法。然而， interrupt 方法能够用来请求终止线程。
当对一个线程调用 interrupt 方法时，线程的中断状态将被置位。这是每个线程都具备的 boolean 标志。每一个线程都应该不时地检查这个标志，以判断线程是否被中断。
调用 Thread.currentThread().isInterrputed() 方法得到当前线程的中断状态是否被置位。可是，若是线程被阻塞，就没法检测中断状态。这是产生 InterruptedException 异常的地方。当在一个被阻塞的线程（调用 sleep 或 wait ）上调用 interrupt 方法时，阻塞调用将会被 Interrupt Exception 异常中断（存在不能被中断的阻塞 I/O 调用，应该考虑选择可中断的调用）。
没有任何语言方面的需求要求一个被中断的线程应该终止。中断一个线程不过是引发它的注意。被中断的线程能够决定如何响应中断。某些线程是如此重要以致于应该处理完异常后，继续执行，而不理会中断。可是，更普通的状况是，线程将简单地将中断做为一个终止的请求。
若是在每次工做迭代以后都调用 sleep 方法（或者其余的可中断方法）， isInterrpted 检测既没有必要也没有用处。若是在种蒜状态被置位时调用 sleep 方法，它不会休眠。相反，它将清除这一状态（！）并抛出 InterrputedException 。所以，若是你的循环调用 sleep ，不会检测中断状态，相反，须要捕获 InterrputedException 异常。
有两个很是相似的方法， interrupted 和 isInterrupted 。 Interrupted 方法是一个静态方法，它检测当前的线程是否被中断。并且，调用 interrupted 方法会清除该线程的中断状态。另外一方面， isInterrupted 方法是一个实例方法，可用来检验是否有线程被中断。调用这个方法不会改变中断状态。
java.lang.Thread 1.0
void interrupt()
向线程发送中断请求。线程的中断状态将设置为 true 。若是目前该线程被一个 sleep 调用阻塞，那么， InterruptedException 异常被抛出。
static boolean interrupted()
测试当前线程（即正在执行这一命令的线程）是否被中断。注意，这是一个静态方法。这一调用会产生反作用-它将当前线程的中断状态重置为false。
boolean isInterrupted()
测试线程是否被终止。不像静态的中断方法，这一调用不改变线程的中断状态。
static Thread currentThread()
返回表明当前执行线程的 Thread 对象。
14.3 线程状态
线程能够有以下6种状态：
New (新建立)
Runnable (可运行)
Blocked (被阻塞)
Waiting (等待)
Timed waiting (计时等待)
Terminated (被终止)
14.3.1 新建立线程
当用new操做符建立一个新线程，如 new Thread(r) ，该线程尚未开始运行。这意味着它的状态是 new 。当一个线程处于新建立状态时，程序尚未开始运行线程中的代码。在线程运行以前还有一些基本工做要作。
14.3.2 可运行线程
一旦调用 start 方法，线程处于 runnable 状态。一个可运行的线程可能正在运行也可能没有运行，这取决于操做系统给线程提供运行的时间。（ Java 的规范说明没有将它做为一个单独状态。一个正在运行中的线程仍然处于可运行状态。）
一旦一个线程开始运行，它没必要始终保持运行。事实上，运行中的线程被中断，目的是为了让其余线程得到运行机会。线程调度的细节依赖于操做系统提供的服务。抢占式调度系统给每个可运行线程一个时间片来执行任务。当时间片用完，操做系统剥夺该线程的运行权，并给另外一个线程运行机会。当选择下一个线程时，操做系统考虑线程的优先级。
在任何给定时刻，一个可运行的线程可能正在运行也可能没有运行（这就是为何将这个状态称为可运行而不是运行）。
14.3.3 被阻塞线程和等待线程
当线程处于被阻塞或等待状态时，它暂时不活动。它不运行任何代码且消耗最少资源。直到线程调度器从新激活它。细节取决于它是怎样达到非活动状态的。
当一个线程试图获取一个内部的对象锁（而不是 java.util.concurrect 库中的锁），而该锁被其余线程持有，则该线程进入阻塞状态。当全部其余线程释放该锁，而且线程调度器容许本线程持有它的时候，该线程将变成非阻塞状态。
当线程等待另外一个线程通知调度器一个条件时，它本身进入等待状态。在调用 Object.wait 方法或 Thread.join 方法，或者是等待 java.util.concurrent 库中的 Lock 或 Condition 时，就会出现这种状况。实际上，被阻塞状态与等待状态是由很大不一样的。
有几个方法有一个超时参数。调用它们致使线程进入计时等待（ timed waiting ）状态。这一状态将一直保持到超时期满或者接收到适当的通知。带有超时参数的方法有 Thread.sleep 和 Object.wait 、 Thread.join 、 Lock.tryLock 以及 Condition.awit 的计时版。
当一个线程被阻塞或等待时（或终止时），另外一个线程被调度为运行状态。当一个线程被从新激活（例如，由于超时期满或成功地得到一个锁），调度器检查它是否具备比当前运行线程更高的优先级。若是是这样，调度器从当前运行线程中挑选一个，剥夺其运行权，选择一个新的线程运行。
线程状态图
14.3.4 被终止的线程
线程因以下两个缘由之一而被终止：
由于 run 方法正常退出而天然死亡。
由于一个没有捕获的异常终止了 run 方法而意外死亡。
特别是，能够调用线程的 stop 方法杀死一个线程。该方法抛出 ThreadDeath 错误对象，由此杀死线程。可是， stop 方法已过期，不要在本身的代码中调用这个方法。
java.lang.Thread 1.0
void join()
等待终止指定的线程。
void join(long millis)
等待指定的线程死亡或者通过指定的毫秒数。
Thread.State getState() 5.0
获得这一线程的状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING或TERMINATED之一。
void stop()
中止该线程。这一方法已过期。
void suspend()
暂停这一线程的执行。这一方法已过期。
void resume()
恢复线程。这一方法仅仅在调用suspend()以后调用。这一方法已过期。
14.4 线程属性
线程的各类属性，其中包括：线程优先级、守护线程、线程组以及处理未捕获异常的处理器。
14.4.1 线程优先级
在 Java 程序设计语言中，每个线程有一个优先级。默认状况下，一个线程继承它的父线程的优先级。能够用 setPriority 方法提升或下降任何一个线程的优先级。能够将优先级设置为在 MIN_PRIORITY (在 Thread 类中定义为 1 )与 MAX_PRIORITY (定义为 10 )之间的任何值。 NORM_PRIORITY 被定义为 5 。
每当线程调度器有机会选择新线程时，它首先选择具备较高优先级的线程。可是，线程优先级是高度依赖于系统的。当虚拟机依赖于宿主机平台的线程实现机制时， Java 线程的优先级被映射到宿主主机平台的优先级上，优先级个数也许更多，也许更少。
Windows 有 7 个优先级别。一些 Java 优先级将映射到相同的操做系统优先级。在 Sun 为 Linux 提供的 Java 虚拟机，线程的优先级被忽略-全部线程具备相同的优先级。
java.lang.Thread 1.0
void setPriority(int newPriority)
设置线程的优先级。优先级必须在Thread.MIN_PRIORITY与Thread.MAX_PRIORITY之间。通常使用Thread.NORM_PRIORITY优先级。
static int MIN_PRIORITY
线程的最小优先级。最小优先级的值为1。
static int NORM_PRIORITY
线程的默认优先级。默认优先级为5。
static int MAX_PRIORITY
线程的最高优先级。最高优先级的值为10。
static void yield()
致使当前执行线程处于让步状态。若是有其余的可运行线程具备至少与此线程一样高的优先级，那么这些线程接下来会被调度。注意，这是一个静态方法。
14.4.2 守护线程
能够经过 t.setDaemon(true) 将线程转换为守护线程（ daemon thread ）。守护线程的惟一用途是为其余线程提供服务。计时线程就是一个例子，它定时地发送“计时器嘀嗒”信号给其余线程或清空过期的高速缓存项的线程。当只剩下守护线程时，虚拟机就退出了，因为若是只剩下守护线程，就不必继续运行程序了。
守护线程应该永远不去访问固有资源，如文件、数据库，由于它会在任什么时候候甚至在一个操做的中间发生中断。
java.lang.Threed 1.0
void setDaemon(boolean isDaemon)
标识该线程为守护线程或用户线程。这一方法必须在线程启动以前调用。
14.4.3 未捕获异常处理器
线程的 run 方法不能抛出任何被检测的异常，可是，不被检测的异常会致使线程终止。在这种状况下，线程就死亡了。
可是，不须要任何 catch 子句来处理能够被传播的异常。相反，就在线程死亡以前，异常被传递到一个被用于未捕获异常的处理器。
该处理器必须属于一个实现 Thread.UncaughtExceptionHandler 接口的类。这个接口只有一个方法。
void uncaughtException(Thread t,Throwable e)
能够用 setUncaughtExceptionHandler 方法为任何线程安装一个处理器。也能够用 Thread 类的静态方法 setDefaultUncaughtExceptionHandler 为全部线程安装一个默认的处理器。替换处理器可使用日志API发送未捕获异常的报告到日志文件。
若是不安装默认的处理器，默认的处理器为空。可是，若是不为独立的线程安装处理器，此时的处理器就是该线程的 ThreadGroup 对象。
线程组是一个能够统一管理的线程集合。默认状况下，建立的全部线程属于相同的线程组，可是，也可能会创建其余的组。如今引入了更好的特性用于线程集合的操做，因此建议不要在本身的程序中使用线程组。
ThreadGroup 类实现 Thread.UncaughtExceptionHandler 接口。它的 uncaughtException 方法作以下操做：
1）若是该线程组有父线程组，那么父线程组的 uncaughtException 方法被调用。
2）不然，若是 Thread.getDefaultExceptionHandler 方法返回一个非空的处理器，则调用该处理器。
3）不然，若是 Throwable 是 ThreadDeath 的一个实例，什么都不作。
4）不然，线程的名字以及 Throwable 的栈跟踪被输出到 System.err 上。
java.lang.Thread 1.0
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) 5.0
static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() 5.0
设置或获取未捕获异常的默认处理器。
void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) 5.0
Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() 5.0
设置或获取未捕获异常的处理器。若是没有安装处理器，则将线程组对象做为处理器。
java.lang.Thread.UncaughtExceptionHandler 5.0
void uncaughtException(Thread t,Throwable e)
当一个线程因未捕获异常而终止，按规定要将客户报告记录到日志中。
参数：t 因为未捕获异常而终止的线程
e 未捕获的异常对象
java.lang.ThreadGroup 1.0
void uncaughtException(Thread t,Throwable e)
若是有父线程组，调用父线程组的这一方法；或者，若是 Thread 类有默认处理器，调用该处理器，不然，输出栈踪影到标准错误流上（可是，若是 e 是一个 ThreadDeath 对象，栈踪影是被禁用的。 ThreadDeath 对象 stop 方法产生，而该方法已通过时）。
14.5 同步
若是两个线程存取相同的对象，而且每个线程都调用了一个修改该对象状态的方法，这样一个状况一般称为竞争条件（ race condition ）。
14.5.1 竞争条件的一个例子
银行转帐例子
14.5.2 竞争条件详解
一条名利是由几条指令组成的，执行它们的线程能够在任何一条指令点上被中断。
14.5.3 锁对象
有两种机制防止代码块受并发访问的干扰。Java语言提供一个 synchronized 关键字达到这一目的，而且 Java SE 5.0 引入了 ReentrantLock 类。 synchronized 关键字自动提供了一个锁以及相关的“条件”，对于大多数须要显示锁的状况，这是很遍历的。 java.util.concurrent 框架为这些基础机制提供独立的类。
用 ReentrantLock 保护代码块的基本结构以下：
myLock.lock(); //a ReentrantLock object
try
{
critical section
}
finally
{
myLock.unlock();//make sure the lock is unlocked even if an exception is three
}
这一结构确保任什么时候刻只有一个线程进入临界区。一旦一个线程封锁了锁对象，其余任何线程都没法经过 lock 语句。当其余线程调用 lock 时，它们被阻塞，直到第一个线程释放锁对象。
把解锁操做放在 finally 子句以内是相当重要的。若是在临界区的代码抛出异常，锁必须被释放。不然，其余线程将永远阻塞。
若是使用锁，就不能使用带资源的 try 语句。首先，解锁方法名不是 close 。不过，即便将它重命名，带资源的 try 语句也没法正常工做。它的首部但愿声明一个新变量。可是若是使用一个锁，可能想使用多个线程共享的那个变量（而不是新变量）。
锁是可重入的，由于线程能够重复地得到已经持有的锁。锁保持一个持有计数（ hold count ）来跟踪对 lock 方法的嵌套调用。线程在每一次调用lock都要调用 unlock 来释放锁。因为这一特性，被一个锁保护的代码能够调用另外一个使用相同的锁的方法。
一般，可能想要保护需若干个操做来更新或检查共享对象的代码块。要确保这些操做完成后，另外一个线程才能使用相同对象。
要留心临界区中的代码，不要由于异常的抛出而跳出了临界区。若是在临界区代码结束以前抛出了异常， finally 子句将释放锁，但会使对象可能处于一种受损状态。
java.util.concurrent.locks.Lock 5.0
void lock()
获取这个锁；若是锁同时被另外一个线程拥有则发生阻塞。
void unlock()
释放这个锁。
java.util.concurrent.locks.ReentrantLock 5.0
ReentrantLock()
构建一个能够被用来保护临界区的可重入锁。
ReentrantLock(boolean fair)
构建一个带有公平策略的锁。一个公平锁偏心等待时间最长的线程。可是么这一公平的保证将大大下降性能。因此，默认状况下，锁没有被强制为公平的。
听起来公平锁更合理一些，可是使用公平锁比使用常规锁要慢不少。只有当你确实了解本身要作什么而且对于你要解决的问题有一个特定的理由必须使用公平锁的时候，才可使用公平锁。即便使用公平锁，也没法确保线程调度器是公平的。若是线程调度器选择忽略一个线程，而该线程为了这个锁已经等待了很长时间，那么就没有机会公平地处理这个锁了。
14.5.4 条件对象
一般，线程进入临界区，却发如今某一条件知足以后它才能执行。要使用一个条件对象来管理那些已经得到了一个锁可是却不能作有用工做的线程。因为历史的缘由，条件对象常常被称为条件变量（ conditional variable ）。
一个锁对象能够有一个或多个相关的条件对象。能够用 newCondition 方法得到一个条件对象。习惯上给每个条件对象命名为能够反映它锁表达的条件的名字。若是条件不知足，调用 Condition.await() 。当前线程如今被阻塞了，并放弃了锁。
等待得到锁的线程和调用 await 方法的线程存在本质上的不一样。一旦一个线程调用 await 方法，它进入该条件的等待集。当锁可用时，该线程不能立刻解除阻塞。相反，它处于阻塞状态，直到另外一个线程调用同一条件上的 singalAll 方法时为止。 singalAll() 调用从新激活由于这一条件而等待的全部线程。当这些线程从等待集中移出时，它们再次成为可运行的，调度器将再次激活它们。同时，它们将试图从新进入该对象。一旦锁成为可用的，它们中的某个将从 await 调用返回，得到该锁并从被阻塞的地方继承执行。
此时，线程应该再次测试该条件。因为没法确保该条件被知足 -signalAll 方法仅仅是通知正在等待的线程：此时有可能已经知足条件，值得再次去检测该条件。
一般，对 await 的调用应该在以下形式的循环体中：
while(!(ok to proceed))
condition.await();
相当重要的是最终须要某个其余线程调用 signalAll 方法。当一个线程调用 await 时，它没有办法从新激活自身。它寄但愿于其余线程。若是没有其余线程来从新激活等待的线程，它就永远再也不运行了。这将致使使人不快的死锁（ deadlock ）现象。若是全部其余线程被阻塞，最后一个活动线程在解除其余线程的阻塞状态以前就调用 await 方法，那么它也被阻塞。没有任何线程能够解除其余线程的阻塞，那么该程序就挂起了。
应该什么时候调用 signalAll 呢？经验上讲，在对象的状态有利于等待线程的方向改变时调用 signalAll 。
注意调用 signalAll 不会当即激活一个等待线程。它仅仅解除等待线程的阻塞，以便这些线程能够在当前线程退出同步方法以后，经过竞争实现对对象的访问。
另外一个方法 signal ，则是随机解除等待集中某个线程的阻塞状态。这比解除全部线程的阻塞更加有效，但也存在危险。若是随机选择的线程发现本身仍然不能运行，那么它再次被阻塞。若是没有其余线程再次调用 signal ，那么系统就死锁了。
当一个线程拥有某个条件的锁时，它仅仅能够在该条件上调用 await 、 signalAll 或 signal 方法。
java.util.concurrent.locks.Lock 5.0
Condition newCondition()
返回一个与该锁相关的条件对象。
java.util.concurrent.locks.Condition 5.0
void await()
将该线程放到条件的等待集中。
void signalAll()
解除该条件的等待集中的全部线程的阻塞状态。
void signal()
从该条件的等待集中随机地选择一个线程，解除其阻塞状态。
14.5.5 synchronized关键字
锁和条件的关键之处：
锁用来保护代码片断，任什么时候刻只能有一个线程执行被保护的代码。
锁能够管理试图进入被保护代码段的线程。
锁能够拥有一个或多个相关的条件对象。
每一个条件对象管理那些已经进入被保护的代码段但还不能运行的线程。
从 1.0 版开始， Java 中的每个对象都有一个内部锁。若是一个方法用 synchronized 关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，线程必须得到内部的对象锁。
内部对象锁只有一个相关条件。 wait 方法添加一个线程到等待集中， notifyAll/notify 方法解除等待线程的阻塞状态。换句话说，调用 wait 或 notifyAll 等价于
intrinsicCondition.await();
intrinsicCondition.signalAll();
wait 、 notifyAll 以及 notify 方法是 Object 类的 final 方法。 Condition 方法必须被命名为 await 、 signalAll 和 signal 以便它们不会与那些方法发生冲突。
将静态方法声明为 synchronized 也是合法的。若是调用这个方法，该方法得到相关的类对象的内部类。所以，没有其余线程能够调用同一个类的这个或任何其余的同步静态方法。
内部锁和条件存在一些局限。包括：
不能中断一个正在试图得到锁的线程。
试图得到锁时不能设定超时。
每一个锁仅有单一的条件，多是不够的。
在代码中应该使用哪种？ Lock 和 Conditon 对象仍是同步方法？下面是一些建议：
最好既不使用 Lock/Condition 也不实用 synchronized 关键字。在许多状况下你可使用 java.util.concurrent 包中的一种机制，它会为你处理全部的加锁。
若是 synchronized 关键字适合你的程序，那么请尽可能使用它。这样能够减小编写的代码数量，减小出错的概率。
若是特别须要 Lock/Condition 结构提供的特有特性时，才使用 Lock/Condition 。
java.lang.Object 1.0
void notifyAll()
解除那些在该对象上调用 wait 方法的线程的阻塞状态。该方法只能在同步方法或同步块内部调用。若是当前线程不是对象锁的持有者，该方法抛出一个 IllegalMonitorStateException 异常。
void notify()
随机选择一个在该对象上调用 wait 方法的线程，解除其阻塞状态。改方法只能在一个同步方法或同步块中调用。若是当前线程不是对象锁的持有者，该方法抛出一个 IllegalMonitorStateException 异常。
void wait()
致使线程进入等待状态直到它被通知。该方法只能在一个同步方法中调用。若是当前线程不是对象锁的持有者，该方法抛出一个 IllegalMonitorStateException 异常。
void wait(long millis)
void wait(long millis,int nanos)
致使线程进入等待状态直到它被通知或者通过指定的时间。这些方法只能在一个同步方法中调用。若是当前线程不是对象锁的持有者该方法抛出一个 IllegalMonitorStateException 异常。
参数：millis 毫秒数
nanos 纳秒数，<1 000 000
14.5.6 同步阻塞
每个 Java 对象有一个锁。线程能够经过调用同步方法得到锁。还有另外一种机制能够得到锁，经过进入一个同步阻塞。当线程进入以下形式的阻塞：
synchronized(obj) //this is the synchronized block
{
critical section
}
因而它得到 obj 的锁。
使用一个对象的锁来实现额外的原子操做，实际上称为客户端锁定（ client-slide locking ）。客户端锁定是很是脆弱的，一般不推荐使用。
14.5.7 监视器概念
锁和条件是线程同步的强大工具，可是，严格来说，它们不是面向对象的。多年来，研究人员努力寻找一种方法，能够在不须要程序员考虑如何加锁的状况下，就能够保证多线程的安全性。最成功的解决方案之一是监视器（ monitor ），这一律念最先是由 Per Brinch Hansen 和 Tony Hoare 在 20 世纪 70 年代提出的。用 Java 的术语来说，监视器具备以下特性：
监视器是只包含私有域的类。
每一个监视器的对象有一个相关的锁。
使用该锁对全部的方法进行加锁。
该锁能够有任意多个相关条件。
Java 设计者以不是很精确的方式采用了监视器概念， Java 中的每个对象有一个内部的锁和内部的条件。若是一个方法用 synchronized 关键字声明，那么，它表现的就像是一个监视器方法。经过调用 wait/notifyAll/notify 访问条件变量。
在下述的 3 个方面 Java 对象不一样于监视器，从而使得线程的安全性降低。
域不要求必须是 private 。
方法不要求必须是 synchronized 。
内部锁对客户是可用的。
14.5.8 Volatile 域
有时，仅仅为了读写一个或两个实例域就使用同步，显得开销过大了。毕竟，什么地方能出错呢？遗憾的是，使用现代的处理器与编译器，出错的可能性很大。
多处理器的计算机可以暂时在寄存器或本地内存缓冲区中保存内存中的值。结果是，运行在不一样处理器上的线程可能在同一个内存位置取到不一样的值。
编译器能够改变指令执行的顺序以使吞吐量最大化。这种顺序上的变化不会改变代码语义，可是编译器假定内存的值仅仅在代码中有显式的修改指令时才会改变。然而，内存的值能够被另外一个线程改变。
若是你使用锁来保护能够被多个线程访问的代码，那么能够不考虑这种问题。编译器被要求经过在必要的时候刷新本地缓存来保持锁的效应，而且不能不正当地从新排序指令。
volatile 关键字为实例域的同步访问提供了一种免锁机制。若是声明一个域为 volatile ，那么编译器和虚拟机就知道该域是可能被另外一个线程并发更新的。
Volatile 变量不能提供原子性。例如，方法
private volatile boolean done;
public void flipDone(){done = !done;} //not atomic
不能确保翻转域中的值。
14.5.9 final 变量
除非使用域或 volatile 修饰符，不然没法从多个线程安全地读取一个域。还有一种状况能够安全地访问一个共享域，即这个域声明为 final 时。考虑如下声明：
final Map<String,Double> accounts = new HashMap();
其余线程会在构造函数完成构造以后才看到这个 accounts 变量。
若是不使用 final ，就不能保证其余线程看到的是 accounts 更新后的值，它们可能都只是看到 null ，而不是新构造的 HashMap 。
对这个映射表的操做并非线程安全的。若是多个线程在读写这个映射表，仍然须要进行同步。
14.5.10 原子性
假设对共享变量除了赋值以外并不完成其余操做，那么能够将这些共享变量声明为 volatic 。
java.util.concurrent.atomic 包中有不少类使用了很高效的机器级指令（而不是使用锁）来保证其余操做的原子性。例如， AtomicInteger 类提供了方法 incrementAndGet 和 decrementAndGet ，它们分别以原子方式将一个整数自增或自减。能够安全地使用 AtomicInteger 做为共享计数器而无须同步。
另外这个包中还包含 AtomicBoolean 、 AtomicLong 和 AtomicReference 以及 Boolean 值、整数、 long 值和引用的原子数组。应用程序员不该该使用这些类，它们仅供那些开发并发工具的系统程序员使用。
14.5.11 死锁
有可能会由于每个线程要等待条件而致使全部线程都被阻塞。这样的状态称为死锁（ deadlock ）。
Java 编程语言中没有任何东西能够避免或打破这种死锁现象，必须仔细设计程序，以确保不会出现死锁。
14.5.12 线程局部变量
有时可能要避免共享变量，使用 ThreadLocal 辅助类为各个线程提供各自的实例。
要为每一个线程构造一个实例，可使用如下代码：
public static final ThreadLocal< SimpleDateFormat > dateFormat = new ThreadLocal< SimpleDateFomrat >()
{
protected SimpleDateFormat initialValue()
{
return new SimpleDateFormat("yyyy-MM-dd");
}
}
要访问具体的格式化方法，能够调用：
String dateStamp = dateFormat.get().format(new Date());
在一个给定线程中首次调用 get 时，会调用 initilaValue 方法。在此以后， get 方法会返回属于当前线程的那个实例。
在多个线程中生成随机数也存在相似的问题。 java.util.Random 类是线程安全的。可是若是多个线程须要等待一个共享的随机数生成器，这会很低效。
可使用 ThreadLocal 辅助类为各个线程提供一个单独的生成器，不过 Java SE 7 还另外提供一个便利类。只须要作一下调用：
int random = ThreadLocalRandom.current().nextInt(upperBound);
ThreadLocalRandom.current() 调用会返回特定于当前线程的 Random 类实例。
java.lang.ThreadLocal< T > 1.2
T get()
获得这个线程的当前值。若是是首次调用get，会调用 initialize 来获得这个值。
protected initialize()
应覆盖这个方法来提供一个初始值。默认状况下，这个方法返回 null 。
void set(T t)
为这个线程设置一个新值。
void remove()
删除对应这个线程的值。
java.util.concurrent.ThreadLocalRandom 7
static ThreadLocalRandom current()
返回特定于当前线程的 Random 类实例。
14.5.13 锁测试与超时
线程在调用 lock 方法来得到另外一个线程所持有的锁的时候，极可能发生阻塞。应该更加谨慎地申请锁。
TimeUnit 是一个枚举类型，能够取的值包括 SECONDS 、 MILLISECONDS 、 MICROSECONDS 和 NANOSECONDS 。
lock 方法不能被中断。若是一个线程在等待得到一个锁时被中断，中断线程在得到锁以前一直处于阻塞状态。若是出现死锁，那么， lock 方法就没法终止。
然而，若是调用带有用超时参数的 tryLock ，那么若是线程在等待期间被中断，将抛出 InterruptedException 异常。这是一个很是有用的特性，由于容许程序打破死锁。
也能够调用 lockInterruptibly 方法。它就至关于一个超时设为无限的 tryLock 方法。
在等待一个条件时，也能够提供一个超时：
myCondition.await(100,TimeUnit.MILLISECONDS)
若是一个线程被另外一个线程经过调用 signalAll 或 signal 激活，或者超时时限已达到，或者线程被中断，那么 await 方法将返回。
若是等待的线程被中断， await 方法将抛出一个 InterruptedException 异常。在你但愿出现这种状况时线程继续等待（可能不太合理），可使用 awaitUniterruptibly 方法代替 await 。
java.util.concurrent.locks.Lock 5.0
boolean tryLock()
尝试得到锁而没有发生阻塞；若是成功返回真。这个方法会抢夺可用的锁，即便该锁有公平加锁策略，即使其余线程已经等待好久也是如此。
boolean tryLock(long time,TimeUnit unit)
尝试得到锁，阻塞时间不会超过给定的值；若是成功返回 true 。
void lockInterruptibly()
得到锁，可是会不肯定地发生阻塞。若是线程被中断，抛出一个 InterruptedException 异常。
java.util.concurrent.locks.Condition 5.0
boolean await(long time,TimeUnit unit)
进入该条件的等待集，直到线程从等待集中移出或等待了指定的时间以后才解除阻塞。。若是由于等待时间到了而返回就返回 false ，不然返回 true 。
void awaitUninterruptinly()
进入该条件的等待集，直到线程从等待集移出才解除阻塞。若是线程被中断，该方法不会抛出 InterruptedException 异常。
14.5.14 读/写锁
java.util.concurrent.locks包定义了两个锁类， ReentrantLock 类和 ReentrantReadWriteLock 类。若是不少线程从一个数据结构读取数据而不多线程修改其中数据的话，后者是十分有用的。在这种状况下，容许对读者共享访问是合适的。固然，写者线程依然必须是互斥访问的。
使用读/写锁的必要步骤：
（1）构造一个ReentrantReadWriteLock对象：
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
（2）抽取读锁和写锁：
private Lock readLock = rwl.readLock();
private Lock writeLock = rwl.writeLock();
（3）对全部的获取方法加读锁：
public double getTotalBalance()
{
readLock.lock();
try{...}
finally{readLock.unlock();}
}
（4）对全部的修改方法加写锁：
public void transfer(...)
{
writeLock.lock();
try{...}
finally{writeLock.unlock();}
}
java.util.concurrent.locks.ReentrantReadWriteLock 5.0
Lock readLock()
获得一个能够被多个读操做共用的读锁，但会排斥全部写操做。
Lock writeLock()
获得一个写锁，排斥全部其余的读操做和写操做。
14.5.15 为何弃用stop和suspend方法
初始的Java版本定义了一个 stop 方法用来终止一个线程，以及一个 suspend 方法来阻塞一个线程直至另外一个线程调用 resume 。 stop 和 suspend 方法有一些共同点：都试图控制一个给定线程的行为。
这两个方法已经弃用。 stop 方法天生就不安全，经验证实 suspend 方法会常常致使死锁。
stop 方法终止全部未结束的方法，包括 run 方法。当线程被终止，当即释放被它锁住的全部对象的锁。这会致使对象处于不一致的状态。
当线程要终止另外一个线程时，没法知道何时调用 stop 方法是安全的，何时致使对象被破坏。所以，该方法被弃用了。在但愿中止线程的时候应该中断线程，被中断的线程会在安全的时候中止。
一些做者声称 stop 方法被弃用是由于它会致使对象被一个已中止的线程永久锁定。可是，这一说法是错误的。从技术上讲，被中止的线程经过抛出 ThreadDeath 异常退出全部它所调用的同步方法。结果是，该线程释放它持有的内部对象锁。
与 stop 不一样， suspend 不会破坏对象。可是，若是用 suspend 方法的线程试图得到同一个锁，那么，该锁在恢复以前是不可用的。若是调用 suspend 方法的线程试图得到同一个锁，那么程序死锁：被挂起的线程等着被恢复，而将其挂起的线程等待得到锁。
若是想安全地挂起线程，引入一个变量 suspendRequested 并在 run 方法的某个安全的地方测试它，安全的地方是指该线程没有封锁其余线程须要的对象的地方。当该线程发现 suspendRequested 变量已经设置，将会保持等待状态直到它再次得到为止。
14.6 阻塞队列
对于许多线程问题，能够经过使用一个或多个队列以优雅且安全的方式将其形式化。
当试图向队列添加元素而队列已满，或是想从队列移除元素而队列为空的时候，阻塞队列（ bolcking queue ）致使线程阻塞。在协调多个线程以前的合做时，阻塞队列是一个有用的工具。工做者线程能够周期性地将中间结果存储在阻塞队列中。其余的工做者线程移出中间结果并进一步加以修改。队列会自动的平衡负载。若是第一个线程集运行得比第二个慢，第二个线程集在等待结果时会阻塞。若是第一个线程集运行得快，它将等待第二个队列集遇上来。
阻塞队列方法
方法
正常动做
特殊状况下的动做
add
添加一个元素
若是队列满，则抛出IllegalStateException异常
element
返回队列的头元素
若是队列空，抛出NoSuchElementException异常
offer
添加一个元素并返回true
若是队列满，返回false
peek
返回队列的头元素
若是队列空，则返回null
poll
移出并返回队列的头元素
若是队列空，则返回null
put
添加一个元素
若是队列满，则阻塞
remove
移出并返回头元素
若是队列空，则抛出NoSuchElementException异常
take
移出并返回头元素
若是队列空，则阻塞
阻塞队列方法分为如下 3 类，这取决于当队列满或空时它们的响应方式。若是将队列看成线程管理工具来使用，将要用到 put 和 take 方法。当试图向满的队列中添加或从空的队列中移出元素时， add 、remove和element操做抛出异常。固然，在一个多线程程序中，队列会在任什么时候候空或满，所以，必定要使用offer、poll和peek方法做为替代。这些方法若是不能完成任务，只是给出一个错误提示而不会抛出异常。
poll和peek方法返回空来指示失败。所以，向这些队列中插入null值是非法的。
还有带有超市的offer方法和poll方法的变体。例如，下面的调用：
boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);
尝试在100毫秒的时间内在队列的尾部插入一个元素。若是成功返回true；不然，达到超时时，返回false。相似地，下面的调用：
Object head = q.poll(100,TimeUnit.MILLISEDS);
尝试用100毫秒的时间移除队列的头元素；若是成功返回头元素，不然，达到在超时时，返回null。
若是队列满，则put方法阻塞；若是队列空，则take方法阻塞。在不带超时参数时，offer和poll方法等效。
java.util.concurrent包提供了阻塞队列的几个变种。默认状况下，LinkedBlockingQueue的容量是没有上边界的，可是，也能够选择指定最大容量。LinkedBlockingDeque是一个双端的版本。ArrayBlockingQueue在构造时须要指定容量，而且有一个可选的参数来指定是否须要公平性。若设置了公平参数，则那么等待了最长时间的线程会优先获得处理。一般，公平性会下降性能，只有在确实很是须要时才使用它。
PriorityBlockingQueue是一个带优先级的队列，而不是先进先出队列。元素按照它们的优先级顺序被移出。该队列是没有容量上限，可是，若是队列是空的，取元素的操做会阻塞。
DelayQueue包含是Delayed接口的对象：
interface Delayed extends Comparable< Delayed >
{
long getDelay(TimeUnit unit);
}
getDelay方法返回对象的残留延迟。负值表示延迟已经结束。元素只有在延迟用完的状况下才能从DelayQueue移除。还必须实现compareTo方法。DelayQueue使用该方法对元素进行排序。
Java SE 7增长了一个TransferQueue接口，容许生产者线程等待，直到消费者准备就绪能够接收一个元素。若是生产者调用
q.transfer(item);
这个调用会阻塞，直到另外一个线程将元素（item）删除。LinkedTransferQueue实现了这个接口。
java.util.concurrent.ArrayBlockingQueue< E > 5.0
ArrayBlockingQueue(int capacity)
ArrayBlockingQueue(int capacity,boolean fair)
构造一个带有指定的容量和公平性的阻塞队列。该队列用循环数组实现。
java.util.concurrent.LinkedBlockingQueue< E > 5.0
java.uti..concurrent.LinkedBlockingDeque< E > 6.0
LinkedBlockingQueue()
LinkedBlockingDeque()
构造一个无上限的阻塞队列或双向队列，用链表实现。
LinkedBolckingQueue(int capacity)
LinkedBlockingDeque(int capacity)
根据指定容量构建一个有限的阻塞队列或双向队列，用链表实现。
java.util.concurrent.DelayQueue< E extends Delayed > 5.0
DelayQueue()
构造一个包含Delayed元素的无界的阻塞时间有限的阻塞队列。只有那些延迟已经超过期间的元素能够从队列中移出。
java.util.concurrent.Delayed 5.0
long getDelay(TimeUnit unit)
获得该对象的延迟，用给定的时间单位进行度量。
java.util.concurrent.PriorityBlockingQueue< E > 5.0
PriorityBlockingQueue()
PriorityBlockingQueue(int initialCapacity)
PriorityBlockingQueue(int initialCapacity,Comparator<? super E> comparator)
构造一个无边界阻塞优先队列，用堆实现。
参数：initialCapacity 优先队列的初始容量。默认值是11。
comparator 用来对元素进行比较的比较器，若是没有指定，则元素必须实现Comparable接口。
java.util.concurrent.BlockingQueue< E > 5.0
void put(E element)
添加元素，在必要时阻塞。
E take()
移除并返回头元素，必要时阻塞。
boolean offer(E element,long time,TimeUnit unit)
添加给定的元素，若是成功返回true，若是必要时阻塞，直至元素已经被添加或超时。
E poll(long time,TimeUnit unit)
移除并返回头元素，必要时阻塞，直至元素可用或超时用完。失败时返回null。
java.util.concurrent.BolckingDeque< E > 6
void putFirst(E element)
void putLast(E element)
添加元素，必要时阻塞。
E takeFirst()
E takeLast()
移除并但会头元素或尾元素，必要时阻塞。
boolean offerFirst(E element,long time,TimeUnit unit)
boolean offerLast(E element,long time,TimeUnit unit)
添加给定的元素，成功时返回true，必要时阻塞直至元素被添加或超时。
E pollFirst(long time,TimeUnit unit)
E pollLast(long time,TimeUnit unit)
移动并返回头元素或尾元素，必要时阻塞，直至元素可用或超时。失败时返回null。
java.util.concurrent.TransferQueue< E > 7
void transfer(E element)
boolean tryTransfer(E element,long time,TimeUnit unit)
传输一个值，或者尝试在给定的超时时间内传输这个值，这个调用将阻塞，直到另外一个线程将元素删除。第二个方法会在调用成功时返回true。
14.7 线程安全的集合
能够经过提供锁来保护共享数据结构，可是选择线程安全的实现做为替代可能更容易写。
14.7.1 高效的映射表、集合和队列
java.util.concurrent包提供了映射表、有序集合队列的高效实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet和ConcurrentLinkedQueue。这些集合使用复杂的算法，经过容许并发地访问数据结构的不一样部分来使竞争极小化。
与大多数集合不一样，size方法没必要在常量时间内操做。肯定这样的集合当前的大小一般须要遍历。
集合返回弱一致性（weakly consisteut）的迭代器。这意味着迭代器不必定能反映出它们被构造以后的全部的修改，可是，它们不会将同一个值返回两次，也不会抛出Concurrent ModificationException异常。
与之造成对照的是，集合若是在迭代器构造以后发生改变，java.util包中的迭代器将抛出一个ConcurrentModificationException异常。
并发地散列映射表，可高效地支持大量的读者和必定数量的写者。默认状况下，假定能够有多达16个写者线程同时执行。能够有更多的写者线程，可是，若是同一时间多于16个，其余线程将暂时被阻塞。能够指定更大数目的构造器，然而，没有这种必要。
ConcurrentHashMap和ConcurrentSkipListMap类有相应的方法用于原子性的关联插入以及关联删除。putIfAbsent方法自动地添加新的关联，前提是原来没有这一关联。对于多线程访问的缓存来讲这是颇有用的，确保只有一个线程向缓存添加项：
cache.putIfAbsent(key,value);
相反的操做是删除（或许应该叫作removeIfPresent）。调用
cache.remove(key,value);
将原子性地删除键值对，若是它们在映像表中出现的话。最后，
cache.replace(key,oldValue,newValue);
原子性地用新值替换旧值，假定旧值与指定的键值关联。
java.util.concurrent.ConcurrentLinkedQueue< E > 5.0
ConcurrentLinkedQueue< E >()
构造一个能够被多线程安全访问的无边界非阻塞的队列。
java.util.concurrent.ConcurrentLinkedQueue< E > 5.0
ConcurrentSkipListSet< E >()
ConcurrentSkipListSet< E >(Comparator<? super E> comp)
构造一个能够被多线程安全访问的有序集。第一个构造器要求元素实现Comparable接口。
java.util.concurrent.ConcurrentHashMap< K,V > 5.0
java.util.concurrent.ConcurrentSkipListMap< K,V > 6
ConcurrentHashMap< K,V >()
ConcurrentHashMap< K,V >(int initialCapacity)
ConcurrentHashMap< K,V >(int initialCapacity,float loadFactor,int concurrencyLevel)
构造一个能够被多线程安全访问的散列映射表。
参数：initialCapacity 集合的初始容量。默认值为16。
loadFactor 控制调整：若是每个桶的平均负载超过这个因子，表的大小会被从新调整。默认值是0.75。
concurrencyLevel 并发写者线程的估计数目。
ConcurrentSkipListMap< K,V >()
ConcurrentSkipListSet< K,V >(Comparator<? super K> comp)
构造一个能够被多线程安全访问的有序的映像表。第一个构造器要求键实现Comparable接口。
V putIfAbsent(K key,V value)
若是该键没有在映像表中出现，则将给定的值同给定的键关联起来，并返回null。不然返回与该键关联的现有值。
boolean remove(K hey,V value)
若是给定的键与给定的值关联，删除给定的键与值并返回真。不然，返回false。
boolean replace(K key,V oldValue,V newValue)
若是给定的键当前与oldvalue相关联，用它与newValue关联。不然，返回false。
线程因以下两个缘由之一而被终止：
由于 run 方法正常退出而天然死亡。
由于一个没有捕获的异常终止了 run 方法而意外死亡。
特别是，能够调用线程的 stop 方法杀死一个线程。该方法抛出 ThreadDeath 错误对象，由此杀死线程。可是， stop 方法已过期，不要在本身的代码中调用这个方法。
java.lang.Thread 1.0
void join()
等待终止指定的线程。
void join(long millis)
等待指定的线程死亡或者通过指定的毫秒数。
Thread.State getState() 5.0
获得这一线程的状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING或TERMINATED之一。
void stop()
中止该线程。这一方法已过期。
void suspend()
暂停这一线程的执行。这一方法已过期。
void resume()
恢复线程。这一方法仅仅在调用suspend()以后调用。这一方法已过期。
14.4 线程属性
线程的各类属性，其中包括：线程优先级、守护线程、线程组以及处理未捕获异常的处理器。
14.4.1 线程优先级
在 Java 程序设计语言中，每个线程有一个优先级。默认状况下，一个线程继承它的父线程的优先级。能够用 setPriority 方法提升或下降任何一个线程的优先级。能够将优先级设置为在 MIN_PRIORITY (在 Thread 类中定义为 1 )与 MAX_PRIORITY (定义为 10 )之间的任何值。 NORM_PRIORITY 被定义为 5 。
每当线程调度器有机会选择新线程时，它首先选择具备较高优先级的线程。可是，线程优先级是高度依赖于系统的。当虚拟机依赖于宿主机平台的线程实现机制时， Java 线程的优先级被映射到宿主主机平台的优先级上，优先级个数也许更多，也许更少。
Windows 有 7 个优先级别。一些 Java 优先级将映射到相同的操做系统优先级。在 Sun 为 Linux 提供的 Java 虚拟机，线程的优先级被忽略-全部线程具备相同的优先级。
java.lang.Thread 1.0
void setPriority(int newPriority)
设置线程的优先级。优先级必须在Thread.MIN_PRIORITY与Thread.MAX_PRIORITY之间。通常使用Thread.NORM_PRIORITY优先级。
static int MIN_PRIORITY
线程的最小优先级。最小优先级的值为1。
static int NORM_PRIORITY
线程的默认优先级。默认优先级为5。
static int MAX_PRIORITY
线程的最高优先级。最高优先级的值为10。
static void yield()
致使当前执行线程处于让步状态。若是有其余的可运行线程具备至少与此线程一样高的优先级，那么这些线程接下来会被调度。注意，这是一个静态方法。
14.4.2 守护线程
能够经过 t.setDaemon(true) 将线程转换为守护线程（ daemon thread ）。守护线程的惟一用途是为其余线程提供服务。计时线程就是一个例子，它定时地发送“计时器嘀嗒”信号给其余线程或清空过期的高速缓存项的线程。当只剩下守护线程时，虚拟机就退出了，因为若是只剩下守护线程，就不必继续运行程序了。
守护线程应该永远不去访问固有资源，如文件、数据库，由于它会在任什么时候候甚至在一个操做的中间发生中断。
java.lang.Threed 1.0
void setDaemon(boolean isDaemon)
标识该线程为守护线程或用户线程。这一方法必须在线程启动以前调用。
14.4.3 未捕获异常处理器
线程的 run 方法不能抛出任何被检测的异常，可是，不被检测的异常会致使线程终止。在这种状况下，线程就死亡了。
可是，不须要任何 catch 子句来处理能够被传播的异常。相反，就在线程死亡以前，异常被传递到一个被用于未捕获异常的处理器。
该处理器必须属于一个实现 Thread.UncaughtExceptionHandler 接口的类。这个接口只有一个方法。
void uncaughtException(Thread t,Throwable e)
能够用 setUncaughtExceptionHandler 方法为任何线程安装一个处理器。也能够用 Thread 类的静态方法 setDefaultUncaughtExceptionHandler 为全部线程安装一个默认的处理器。替换处理器可使用日志API发送未捕获异常的报告到日志文件。
若是不安装默认的处理器，默认的处理器为空。可是，若是不为独立的线程安装处理器，此时的处理器就是该线程的 ThreadGroup 对象。
线程组是一个能够统一管理的线程集合。默认状况下，建立的全部线程属于相同的线程组，可是，也可能会创建其余的组。如今引入了更好的特性用于线程集合的操做，因此建议不要在本身的程序中使用线程组。
ThreadGroup 类实现 Thread.UncaughtExceptionHandler 接口。它的 uncaughtException 方法作以下操做：
1）若是该线程组有父线程组，那么父线程组的 uncaughtException 方法被调用。
2）不然，若是 Thread.getDefaultExceptionHandler 方法返回一个非空的处理器，则调用该处理器。
3）不然，若是 Throwable 是 ThreadDeath 的一个实例，什么都不作。
4）不然，线程的名字以及 Throwable 的栈跟踪被输出到 System.err 上。
java.lang.Thread 1.0
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) 5.0
static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() 5.0
设置或获取未捕获异常的默认处理器。
void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) 5.0
Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() 5.0
设置或获取未捕获异常的处理器。若是没有安装处理器，则将线程组对象做为处理器。
java.lang.Thread.UncaughtExceptionHandler 5.0
void uncaughtException(Thread t,Throwable e)
当一个线程因未捕获异常而终止，按规定要将客户报告记录到日志中。
参数：t 因为未捕获异常而终止的线程
e 未捕获的异常对象
java.lang.ThreadGroup 1.0
void uncaughtException(Thread t,Throwable e)
若是有父线程组，调用父线程组的这一方法；或者，若是 Thread 类有默认处理器，调用该处理器，不然，输出栈踪影到标准错误流上（可是，若是 e 是一个 ThreadDeath 对象，栈踪影是被禁用的。 ThreadDeath 对象 stop 方法产生，而该方法已通过时）。
14.5 同步
若是两个线程存取相同的对象，而且每个线程都调用了一个修改该对象状态的方法，这样一个状况一般称为竞争条件（ race condition ）。
14.5.1 竞争条件的一个例子
银行转帐例子
14.5.2 竞争条件详解
一条名利是由几条指令组成的，执行它们的线程能够在任何一条指令点上被中断。
14.5.3 锁对象
有两种机制防止代码块受并发访问的干扰。Java语言提供一个 synchronized 关键字达到这一目的，而且 Java SE 5.0 引入了 ReentrantLock 类。 synchronized 关键字自动提供了一个锁以及相关的“条件”，对于大多数须要显示锁的状况，这是很遍历的。 java.util.concurrent 框架为这些基础机制提供独立的类。
用 ReentrantLock 保护代码块的基本结构以下：
myLock.lock(); //a ReentrantLock object
try
{
critical section
}
finally
{
myLock.unlock();//make sure the lock is unlocked even if an exception is three
}
这一结构确保任什么时候刻只有一个线程进入临界区。一旦一个线程封锁了锁对象，其余任何线程都没法经过 lock 语句。当其余线程调用 lock 时，它们被阻塞，直到第一个线程释放锁对象。
把解锁操做放在 finally 子句以内是相当重要的。若是在临界区的代码抛出异常，锁必须被释放。不然，其余线程将永远阻塞。
若是使用锁，就不能使用带资源的 try 语句。首先，解锁方法名不是 close 。不过，即便将它重命名，带资源的 try 语句也没法正常工做。它的首部但愿声明一个新变量。可是若是使用一个锁，可能想使用多个线程共享的那个变量（而不是新变量）。
锁是可重入的，由于线程能够重复地得到已经持有的锁。锁保持一个持有计数（ hold count ）来跟踪对 lock 方法的嵌套调用。线程在每一次调用lock都要调用 unlock 来释放锁。因为这一特性，被一个锁保护的代码能够调用另外一个使用相同的锁的方法。
一般，可能想要保护需若干个操做来更新或检查共享对象的代码块。要确保这些操做完成后，另外一个线程才能使用相同对象。
要留心临界区中的代码，不要由于异常的抛出而跳出了临界区。若是在临界区代码结束以前抛出了异常， finally 子句将释放锁，但会使对象可能处于一种受损状态。
java.util.concurrent.locks.Lock 5.0
void lock()
获取这个锁；若是锁同时被另外一个线程拥有则发生阻塞。
void unlock()
释放这个锁。
java.util.concurrent.locks.ReentrantLock 5.0
ReentrantLock()
构建一个能够被用来保护临界区的可重入锁。
ReentrantLock(boolean fair)
构建一个带有公平策略的锁。一个公平锁偏心等待时间最长的线程。可是么这一公平的保证将大大下降性能。因此，默认状况下，锁没有被强制为公平的。
听起来公平锁更合理一些，可是使用公平锁比使用常规锁要慢不少。只有当你确实了解本身要作什么而且对于你要解决的问题有一个特定的理由必须使用公平锁的时候，才可使用公平锁。即便使用公平锁，也没法确保线程调度器是公平的。若是线程调度器选择忽略一个线程，而该线程为了这个锁已经等待了很长时间，那么就没有机会公平地处理这个锁了。
14.5.4 条件对象
一般，线程进入临界区，却发如今某一条件知足以后它才能执行。要使用一个条件对象来管理那些已经得到了一个锁可是却不能作有用工做的线程。因为历史的缘由，条件对象常常被称为条件变量（ conditional variable ）。
一个锁对象能够有一个或多个相关的条件对象。能够用 newCondition 方法得到一个条件对象。习惯上给每个条件对象命名为能够反映它锁表达的条件的名字。若是条件不知足，调用 Condition.await() 。当前线程如今被阻塞了，并放弃了锁。
等待得到锁的线程和调用 await 方法的线程存在本质上的不一样。一旦一个线程调用 await 方法，它进入该条件的等待集。当锁可用时，该线程不能立刻解除阻塞。相反，它处于阻塞状态，直到另外一个线程调用同一条件上的 singalAll 方法时为止。 singalAll() 调用从新激活由于这一条件而等待的全部线程。当这些线程从等待集中移出时，它们再次成为可运行的，调度器将再次激活它们。同时，它们将试图从新进入该对象。一旦锁成为可用的，它们中的某个将从 await 调用返回，得到该锁并从被阻塞的地方继承执行。
此时，线程应该再次测试该条件。因为没法确保该条件被知足 -signalAll 方法仅仅是通知正在等待的线程：此时有可能已经知足条件，值得再次去检测该条件。
一般，对 await 的调用应该在以下形式的循环体中：
while(!(ok to proceed))
condition.await();
相当重要的是最终须要某个其余线程调用 signalAll 方法。当一个线程调用 await 时，它没有办法从新激活自身。它寄但愿于其余线程。若是没有其余线程来从新激活等待的线程，它就永远再也不运行了。这将致使使人不快的死锁（ deadlock ）现象。若是全部其余线程被阻塞，最后一个活动线程在解除其余线程的阻塞状态以前就调用 await 方法，那么它也被阻塞。没有任何线程能够解除其余线程的阻塞，那么该程序就挂起了。
应该什么时候调用 signalAll 呢？经验上讲，在对象的状态有利于等待线程的方向改变时调用 signalAll 。
注意调用 signalAll 不会当即激活一个等待线程。它仅仅解除等待线程的阻塞，以便这些线程能够在当前线程退出同步方法以后，经过竞争实现对对象的访问。
另外一个方法 signal ，则是随机解除等待集中某个线程的阻塞状态。这比解除全部线程的阻塞更加有效，但也存在危险。若是随机选择的线程发现本身仍然不能运行，那么它再次被阻塞。若是没有其余线程再次调用 signal ，那么系统就死锁了。
当一个线程拥有某个条件的锁时，它仅仅能够在该条件上调用 await 、 signalAll 或 signal 方法。
java.util.concurrent.locks.Lock 5.0
Condition newCondition()
返回一个与该锁相关的条件对象。
java.util.concurrent.locks.Condition 5.0
void await()
将该线程放到条件的等待集中。
void signalAll()
解除该条件的等待集中的全部线程的阻塞状态。
void signal()
从该条件的等待集中随机地选择一个线程，解除其阻塞状态。
14.5.5 synchronized关键字
锁和条件的关键之处：
锁用来保护代码片断，任什么时候刻只能有一个线程执行被保护的代码。
锁能够管理试图进入被保护代码段的线程。
锁能够拥有一个或多个相关的条件对象。
每一个条件对象管理那些已经进入被保护的代码段但还不能运行的线程。
从 1.0 版开始， Java 中的每个对象都有一个内部锁。若是一个方法用 synchronized 关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，线程必须得到内部的对象锁。
内部对象锁只有一个相关条件。 wait 方法添加一个线程到等待集中， notifyAll/notify 方法解除等待线程的阻塞状态。换句话说，调用 wait 或 notifyAll 等价于
intrinsicCondition.await();
intrinsicCondition.signalAll();
wait 、 notifyAll 以及 notify 方法是 Object 类的 final 方法。 Condition 方法必须被命名为 await 、 signalAll 和 signal 以便它们不会与那些方法发生冲突。
将静态方法声明为 synchronized 也是合法的。若是调用这个方法，该方法得到相关的类对象的内部类。所以，没有其余线程能够调用同一个类的这个或任何其余的同步静态方法。
内部锁和条件存在一些局限。包括：
不能中断一个正在试图得到锁的线程。
试图得到锁时不能设定超时。
每一个锁仅有单一的条件，多是不够的。
在代码中应该使用哪种？ Lock 和 Conditon 对象仍是同步方法？下面是一些建议：
最好既不使用 Lock/Condition 也不实用 synchronized 关键字。在许多状况下你可使用 java.util.concurrent 包中的一种机制，它会为你处理全部的加锁。
若是 synchronized 关键字适合你的程序，那么请尽可能使用它。这样能够减小编写的代码数量，减小出错的概率。
若是特别须要 Lock/Condition 结构提供的特有特性时，才使用 Lock/Condition 。
java.lang.Object 1.0
void notifyAll()
解除那些在该对象上调用 wait 方法的线程的阻塞状态。该方法只能在同步方法或同步块内部调用。若是当前线程不是对象锁的持有者，该方法抛出一个 IllegalMonitorStateException 异常。
void notify()
随机选择一个在该对象上调用 wait 方法的线程，解除其阻塞状态。改方法只能在一个同步方法或同步块中调用。若是当前线程不是对象锁的持有者，该方法抛出一个 IllegalMonitorStateException 异常。
void wait()
致使线程进入等待状态直到它被通知。该方法只能在一个同步方法中调用。若是当前线程不是对象锁的持有者，该方法抛出一个 IllegalMonitorStateException 异常。
void wait(long millis)
void wait(long millis,int nanos)
致使线程进入等待状态直到它被通知或者通过指定的时间。这些方法只能在一个同步方法中调用。若是当前线程不是对象锁的持有者该方法抛出一个 IllegalMonitorStateException 异常。
参数：millis 毫秒数
nanos 纳秒数，<1 000 000
14.5.6 同步阻塞
每个 Java 对象有一个锁。线程能够经过调用同步方法得到锁。还有另外一种机制能够得到锁，经过进入一个同步阻塞。当线程进入以下形式的阻塞：
synchronized(obj) //this is the synchronized block
{
critical section
}
因而它得到 obj 的锁。
使用一个对象的锁来实现额外的原子操做，实际上称为客户端锁定（ client-slide locking ）。客户端锁定是很是脆弱的，一般不推荐使用。
14.5.7 监视器概念
锁和条件是线程同步的强大工具，可是，严格来说，它们不是面向对象的。多年来，研究人员努力寻找一种方法，能够在不须要程序员考虑如何加锁的状况下，就能够保证多线程的安全性。最成功的解决方案之一是监视器（ monitor ），这一律念最先是由 Per Brinch Hansen 和 Tony Hoare 在 20 世纪 70 年代提出的。用 Java 的术语来说，监视器具备以下特性：
监视器是只包含私有域的类。
每一个监视器的对象有一个相关的锁。
使用该锁对全部的方法进行加锁。
该锁能够有任意多个相关条件。
Java 设计者以不是很精确的方式采用了监视器概念， Java 中的每个对象有一个内部的锁和内部的条件。若是一个方法用 synchronized 关键字声明，那么，它表现的就像是一个监视器方法。经过调用 wait/notifyAll/notify 访问条件变量。
在下述的 3 个方面 Java 对象不一样于监视器，从而使得线程的安全性降低。
域不要求必须是 private 。
方法不要求必须是 synchronized 。
内部锁对客户是可用的。
14.5.8 Volatile 域
有时，仅仅为了读写一个或两个实例域就使用同步，显得开销过大了。毕竟，什么地方能出错呢？遗憾的是，使用现代的处理器与编译器，出错的可能性很大。
多处理器的计算机可以暂时在寄存器或本地内存缓冲区中保存内存中的值。结果是，运行在不一样处理器上的线程可能在同一个内存位置取到不一样的值。
编译器能够改变指令执行的顺序以使吞吐量最大化。这种顺序上的变化不会改变代码语义，可是编译器假定内存的值仅仅在代码中有显式的修改指令时才会改变。然而，内存的值能够被另外一个线程改变。
若是你使用锁来保护能够被多个线程访问的代码，那么能够不考虑这种问题。编译器被要求经过在必要的时候刷新本地缓存来保持锁的效应，而且不能不正当地从新排序指令。
volatile 关键字为实例域的同步访问提供了一种免锁机制。若是声明一个域为 volatile ，那么编译器和虚拟机就知道该域是可能被另外一个线程并发更新的。
Volatile 变量不能提供原子性。例如，方法
private volatile boolean done;
public void flipDone(){done = !done;} //not atomic
不能确保翻转域中的值。
14.5.9 final 变量
除非使用域或 volatile 修饰符，不然没法从多个线程安全地读取一个域。还有一种状况能够安全地访问一个共享域，即这个域声明为 final 时。考虑如下声明：
final Map<String,Double> accounts = new HashMap();
其余线程会在构造函数完成构造以后才看到这个 accounts 变量。
若是不使用 final ，就不能保证其余线程看到的是 accounts 更新后的值，它们可能都只是看到 null ，而不是新构造的 HashMap 。
对这个映射表的操做并非线程安全的。若是多个线程在读写这个映射表，仍然须要进行同步。
14.5.10 原子性
假设对共享变量除了赋值以外并不完成其余操做，那么能够将这些共享变量声明为 volatic 。
java.util.concurrent.atomic 包中有不少类使用了很高效的机器级指令（而不是使用锁）来保证其余操做的原子性。例如， AtomicInteger 类提供了方法 incrementAndGet 和 decrementAndGet ，它们分别以原子方式将一个整数自增或自减。能够安全地使用 AtomicInteger 做为共享计数器而无须同步。
另外这个包中还包含 AtomicBoolean 、 AtomicLong 和 AtomicReference 以及 Boolean 值、整数、 long 值和引用的原子数组。应用程序员不该该使用这些类，它们仅供那些开发并发工具的系统程序员使用。
14.5.11 死锁
有可能会由于每个线程要等待条件而致使全部线程都被阻塞。这样的状态称为死锁（ deadlock ）。
Java 编程语言中没有任何东西能够避免或打破这种死锁现象，必须仔细设计程序，以确保不会出现死锁。
14.5.12 线程局部变量
有时可能要避免共享变量，使用 ThreadLocal 辅助类为各个线程提供各自的实例。
要为每一个线程构造一个实例，可使用如下代码：
public static final ThreadLocal< SimpleDateFormat > dateFormat = new ThreadLocal< SimpleDateFomrat >()
{
protected SimpleDateFormat initialValue()
{
return new SimpleDateFormat("yyyy-MM-dd");
}
}
要访问具体的格式化方法，能够调用：
String dateStamp = dateFormat.get().format(new Date());
在一个给定线程中首次调用 get 时，会调用 initilaValue 方法。在此以后， get 方法会返回属于当前线程的那个实例。
在多个线程中生成随机数也存在相似的问题。 java.util.Random 类是线程安全的。可是若是多个线程须要等待一个共享的随机数生成器，这会很低效。
可使用 ThreadLocal 辅助类为各个线程提供一个单独的生成器，不过 Java SE 7 还另外提供一个便利类。只须要作一下调用：
int random = ThreadLocalRandom.current().nextInt(upperBound);
ThreadLocalRandom.current() 调用会返回特定于当前线程的 Random 类实例。
java.lang.ThreadLocal< T > 1.2
T get()
获得这个线程的当前值。若是是首次调用get，会调用 initialize 来获得这个值。
protected initialize()
应覆盖这个方法来提供一个初始值。默认状况下，这个方法返回 null 。
void set(T t)
为这个线程设置一个新值。
void remove()
删除对应这个线程的值。
java.util.concurrent.ThreadLocalRandom 7
static ThreadLocalRandom current()
返回特定于当前线程的 Random 类实例。
14.5.13 锁测试与超时
线程在调用 lock 方法来得到另外一个线程所持有的锁的时候，极可能发生阻塞。应该更加谨慎地申请锁。
TimeUnit 是一个枚举类型，能够取的值包括 SECONDS 、 MILLISECONDS 、 MICROSECONDS 和 NANOSECONDS 。
lock 方法不能被中断。若是一个线程在等待得到一个锁时被中断，中断线程在得到锁以前一直处于阻塞状态。若是出现死锁，那么， lock 方法就没法终止。
然而，若是调用带有用超时参数的 tryLock ，那么若是线程在等待期间被中断，将抛出 InterruptedException 异常。这是一个很是有用的特性，由于容许程序打破死锁。
也能够调用 lockInterruptibly 方法。它就至关于一个超时设为无限的 tryLock 方法。
在等待一个条件时，也能够提供一个超时：
myCondition.await(100,TimeUnit.MILLISECONDS)
若是一个线程被另外一个线程经过调用 signalAll 或 signal 激活，或者超时时限已达到，或者线程被中断，那么 await 方法将返回。
若是等待的线程被中断， await 方法将抛出一个 InterruptedException 异常。在你但愿出现这种状况时线程继续等待（可能不太合理），可使用 awaitUniterruptibly 方法代替 await 。
java.util.concurrent.locks.Lock 5.0
boolean tryLock()
尝试得到锁而没有发生阻塞；若是成功返回真。这个方法会抢夺可用的锁，即便该锁有公平加锁策略，即使其余线程已经等待好久也是如此。
boolean tryLock(long time,TimeUnit unit)
尝试得到锁，阻塞时间不会超过给定的值；若是成功返回 true 。
void lockInterruptibly()
得到锁，可是会不肯定地发生阻塞。若是线程被中断，抛出一个 InterruptedException 异常。
java.util.concurrent.locks.Condition 5.0
boolean await(long time,TimeUnit unit)
进入该条件的等待集，直到线程从等待集中移出或等待了指定的时间以后才解除阻塞。。若是由于等待时间到了而返回就返回 false ，不然返回 true 。
void awaitUninterruptinly()
进入该条件的等待集，直到线程从等待集移出才解除阻塞。若是线程被中断，该方法不会抛出 InterruptedException 异常。
14.5.14 读/写锁
java.util.concurrent.locks包定义了两个锁类， ReentrantLock 类和 ReentrantReadWriteLock 类。若是不少线程从一个数据结构读取数据而不多线程修改其中数据的话，后者是十分有用的。在这种状况下，容许对读者共享访问是合适的。固然，写者线程依然必须是互斥访问的。
使用读/写锁的必要步骤：
（1）构造一个ReentrantReadWriteLock对象：
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
（2）抽取读锁和写锁：
private Lock readLock = rwl.readLock();
private Lock writeLock = rwl.writeLock();
（3）对全部的获取方法加读锁：
public double getTotalBalance()
{
readLock.lock();
try{...}
finally{readLock.unlock();}
}
（4）对全部的修改方法加写锁：
public void transfer(...)
{
writeLock.lock();
try{...}
finally{writeLock.unlock();}
}
java.util.concurrent.locks.ReentrantReadWriteLock 5.0
Lock readLock()
获得一个能够被多个读操做共用的读锁，但会排斥全部写操做。
Lock writeLock()
获得一个写锁，排斥全部其余的读操做和写操做。
14.5.15 为何弃用stop和suspend方法
初始的Java版本定义了一个 stop 方法用来终止一个线程，以及一个 suspend 方法来阻塞一个线程直至另外一个线程调用 resume 。 stop 和 suspend 方法有一些共同点：都试图控制一个给定线程的行为。
这两个方法已经弃用。 stop 方法天生就不安全，经验证实 suspend 方法会常常致使死锁。
stop 方法终止全部未结束的方法，包括 run 方法。当线程被终止，当即释放被它锁住的全部对象的锁。这会致使对象处于不一致的状态。
当线程要终止另外一个线程时，没法知道何时调用 stop 方法是安全的，何时致使对象被破坏。所以，该方法被弃用了。在但愿中止线程的时候应该中断线程，被中断的线程会在安全的时候中止。
一些做者声称 stop 方法被弃用是由于它会致使对象被一个已中止的线程永久锁定。可是，这一说法是错误的。从技术上讲，被中止的线程经过抛出 ThreadDeath 异常退出全部它所调用的同步方法。结果是，该线程释放它持有的内部对象锁。
与 stop 不一样， suspend 不会破坏对象。可是，若是用 suspend 方法的线程试图得到同一个锁，那么，该锁在恢复以前是不可用的。若是调用 suspend 方法的线程试图得到同一个锁，那么程序死锁：被挂起的线程等着被恢复，而将其挂起的线程等待得到锁。
若是想安全地挂起线程，引入一个变量 suspendRequested 并在 run 方法的某个安全的地方测试它，安全的地方是指该线程没有封锁其余线程须要的对象的地方。当该线程发现 suspendRequested 变量已经设置，将会保持等待状态直到它再次得到为止。
14.6 阻塞队列
对于许多线程问题，能够经过使用一个或多个队列以优雅且安全的方式将其形式化。
当试图向队列添加元素而队列已满，或是想从队列移除元素而队列为空的时候，阻塞队列（ bolcking queue ）致使线程阻塞。在协调多个线程以前的合做时，阻塞队列是一个有用的工具。工做者线程能够周期性地将中间结果存储在阻塞队列中。其余的工做者线程移出中间结果并进一步加以修改。队列会自动的平衡负载。若是第一个线程集运行得比第二个慢，第二个线程集在等待结果时会阻塞。若是第一个线程集运行得快，它将等待第二个队列集遇上来。
阻塞队列方法
方法
正常动做
特殊状况下的动做
add
添加一个元素
若是队列满，则抛出IllegalStateException异常
element
返回队列的头元素
若是队列空，抛出NoSuchElementException异常
offer
添加一个元素并返回true
若是队列满，返回false
peek
返回队列的头元素
若是队列空，则返回null
poll
移出并返回队列的头元素
若是队列空，则返回null
put
添加一个元素
若是队列满，则阻塞
remove
移出并返回头元素
若是队列空，则抛出NoSuchElementException异常
take
移出并返回头元素
若是队列空，则阻塞
阻塞队列方法分为如下 3 类，这取决于当队列满或空时它们的响应方式。若是将队列看成线程管理工具来使用，将要用到 put 和 take 方法。当试图向满的队列中添加或从空的队列中移出元素时， add 、remove和element操做抛出异常。固然，在一个多线程程序中，队列会在任什么时候候空或满，所以，必定要使用offer、poll和peek方法做为替代。这些方法若是不能完成任务，只是给出一个错误提示而不会抛出异常。
poll和peek方法返回空来指示失败。所以，向这些队列中插入null值是非法的。
还有带有超市的offer方法和poll方法的变体。例如，下面的调用：
boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);
尝试在100毫秒的时间内在队列的尾部插入一个元素。若是成功返回true；不然，达到超时时，返回false。相似地，下面的调用：
Object head = q.poll(100,TimeUnit.MILLISEDS);
尝试用100毫秒的时间移除队列的头元素；若是成功返回头元素，不然，达到在超时时，返回null。
若是队列满，则put方法阻塞；若是队列空，则take方法阻塞。在不带超时参数时，offer和poll方法等效。
java.util.concurrent包提供了阻塞队列的几个变种。默认状况下，LinkedBlockingQueue的容量是没有上边界的，可是，也能够选择指定最大容量。LinkedBlockingDeque是一个双端的版本。ArrayBlockingQueue在构造时须要指定容量，而且有一个可选的参数来指定是否须要公平性。若设置了公平参数，则那么等待了最长时间的线程会优先获得处理。一般，公平性会下降性能，只有在确实很是须要时才使用它。
PriorityBlockingQueue是一个带优先级的队列，而不是先进先出队列。元素按照它们的优先级顺序被移出。该队列是没有容量上限，可是，若是队列是空的，取元素的操做会阻塞。
DelayQueue包含是Delayed接口的对象：
interface Delayed extends Comparable< Delayed >
{
long getDelay(TimeUnit unit);
}
getDelay方法返回对象的残留延迟。负值表示延迟已经结束。元素只有在延迟用完的状况下才能从DelayQueue移除。还必须实现compareTo方法。DelayQueue使用该方法对元素进行排序。
Java SE 7增长了一个TransferQueue接口，容许生产者线程等待，直到消费者准备就绪能够接收一个元素。若是生产者调用
q.transfer(item);
这个调用会阻塞，直到另外一个线程将元素（item）删除。LinkedTransferQueue实现了这个接口。
java.util.concurrent.ArrayBlockingQueue< E > 5.0
ArrayBlockingQueue(int capacity)
ArrayBlockingQueue(int capacity,boolean fair)
构造一个带有指定的容量和公平性的阻塞队列。该队列用循环数组实现。
java.util.concurrent.LinkedBlockingQueue< E > 5.0
java.uti..concurrent.LinkedBlockingDeque< E > 6.0
LinkedBlockingQueue()
LinkedBlockingDeque()
构造一个无上限的阻塞队列或双向队列，用链表实现。
LinkedBolckingQueue(int capacity)
LinkedBlockingDeque(int capacity)
根据指定容量构建一个有限的阻塞队列或双向队列，用链表实现。
java.util.concurrent.DelayQueue< E extends Delayed > 5.0
DelayQueue()
构造一个包含Delayed元素的无界的阻塞时间有限的阻塞队列。只有那些延迟已经超过期间的元素能够从队列中移出。
java.util.concurrent.Delayed 5.0
long getDelay(TimeUnit unit)
获得该对象的延迟，用给定的时间单位进行度量。
java.util.concurrent.PriorityBlockingQueue< E > 5.0
PriorityBlockingQueue()
PriorityBlockingQueue(int initialCapacity)
PriorityBlockingQueue(int initialCapacity,Comparator<? super E> comparator)
构造一个无边界阻塞优先队列，用堆实现。
参数：initialCapacity 优先队列的初始容量。默认值是11。
comparator 用来对元素进行比较的比较器，若是没有指定，则元素必须实现Comparable接口。
java.util.concurrent.BlockingQueue< E > 5.0
void put(E element)
添加元素，在必要时阻塞。
E take()
移除并返回头元素，必要时阻塞。
boolean offer(E element,long time,TimeUnit unit)
添加给定的元素，若是成功返回true，若是必要时阻塞，直至元素已经被添加或超时。
E poll(long time,TimeUnit unit)
移除并返回头元素，必要时阻塞，直至元素可用或超时用完。失败时返回null。
java.util.concurrent.BolckingDeque< E > 6
void putFirst(E element)
void putLast(E element)
添加元素，必要时阻塞。
E takeFirst()
E takeLast()
移除并但会头元素或尾元素，必要时阻塞。
boolean offerFirst(E element,long time,TimeUnit unit)
boolean offerLast(E element,long time,TimeUnit unit)
添加给定的元素，成功时返回true，必要时阻塞直至元素被添加或超时。
E pollFirst(long time,TimeUnit unit)
E pollLast(long time,TimeUnit unit)
移动并返回头元素或尾元素，必要时阻塞，直至元素可用或超时。失败时返回null。
java.util.concurrent.TransferQueue< E > 7
void transfer(E element)
boolean tryTransfer(E element,long time,TimeUnit unit)
传输一个值，或者尝试在给定的超时时间内传输这个值，这个调用将阻塞，直到另外一个线程将元素删除。第二个方法会在调用成功时返回true。
14.7 线程安全的集合
能够经过提供锁来保护共享数据结构，可是选择线程安全的实现做为替代可能更容易写。
14.7.1 高效的映射表、集合和队列
java.util.concurrent包提供了映射表、有序集合队列的高效实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet和ConcurrentLinkedQueue。这些集合使用复杂的算法，经过容许并发地访问数据结构的不一样部分来使竞争极小化。
与大多数集合不一样，size方法没必要在常量时间内操做。肯定这样的集合当前的大小一般须要遍历。
集合返回弱一致性（weakly consisteut）的迭代器。这意味着迭代器不必定能反映出它们被构造以后的全部的修改，可是，它们不会将同一个值返回两次，也不会抛出Concurrent ModificationException异常。
与之造成对照的是，集合若是在迭代器构造以后发生改变，java.util包中的迭代器将抛出一个ConcurrentModificationException异常。
并发地散列映射表，可高效地支持大量的读者和必定数量的写者。默认状况下，假定能够有多达16个写者线程同时执行。能够有更多的写者线程，可是，若是同一时间多于16个，其余线程将暂时被阻塞。能够指定更大数目的构造器，然而，没有这种必要。
ConcurrentHashMap和ConcurrentSkipListMap类有相应的方法用于原子性的关联插入以及关联删除。putIfAbsent方法自动地添加新的关联，前提是原来没有这一关联。对于多线程访问的缓存来讲这是颇有用的，确保只有一个线程向缓存添加项：
cache.putIfAbsent(key,value);
相反的操做是删除（或许应该叫作removeIfPresent）。调用
cache.remove(key,value);
将原子性地删除键值对，若是它们在映像表中出现的话。最后，
cache.replace(key,oldValue,newValue);
原子性地用新值替换旧值，假定旧值与指定的键值关联。
java.util.concurrent.ConcurrentLinkedQueue< E > 5.0
ConcurrentLinkedQueue< E >()
构造一个能够被多线程安全访问的无边界非阻塞的队列。
java.util.concurrent.ConcurrentLinkedQueue< E > 5.0
ConcurrentSkipListSet< E >()
ConcurrentSkipListSet< E >(Comparator<? super E> comp)
构造一个能够被多线程安全访问的有序集。第一个构造器要求元素实现Comparable接口。
java.util.concurrent.ConcurrentHashMap< K,V > 5.0
java.util.concurrent.ConcurrentSkipListMap< K,V > 6
ConcurrentHashMap< K,V >()
ConcurrentHashMap< K,V >(int initialCapacity)
ConcurrentHashMap< K,V >(int initialCapacity,float loadFactor,int concurrencyLevel)
构造一个能够被多线程安全访问的散列映射表。
参数：initialCapacity 集合的初始容量。默认值为16。
loadFactor 控制调整：若是每个桶的平均负载超过这个因子，表的大小会被从新调整。默认值是0.75。
concurrencyLevel 并发写者线程的估计数目。
ConcurrentSkipListMap< K,V >()
ConcurrentSkipListSet< K,V >(Comparator<? super K> comp)
构造一个能够被多线程安全访问的有序的映像表。第一个构造器要求键实现Comparable接口。
V putIfAbsent(K key,V value)
若是该键没有在映像表中出现，则将给定的值同给定的键关联起来，并返回null。不然返回与该键关联的现有值。
boolean remove(K hey,V value)
若是给定的键与给定的值关联，删除给定的键与值并返回真。不然，返回false。
boolean replace(K key,V oldValue,V newValue)
若是给定的键当前与oldvalue相关联，用它与newValue关联。不然，返回false。
第二部分 实验总结
实验1： 导入第13章示例程序，测试程序并进行代码注释。
测试程序1
l 在elipse IDE中调试运行教材585页程序13-1，结合程序运行结果理解程序；
l 将所生成的JAR文件移到另一个不一样的目录中，再运行该归档文件，以便确认程序是从JAR文件中，而不是从当前目录中读取的资源。
l 掌握建立JAR文件的方法；
ResourceTest
package resource;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;
/**
* @version 1.41 2015-06-12
* @author Cay Horstmann
*/
public class ResourceTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new ResourceTestFrame();
frame.setTitle("ResourceTest");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);//可视化
});
}
}
/**
* A frame that loads image and text resources.
*/
class ResourceTestFrame extends JFrame
{
private static final int DEFAULT_WIDTH = 300;
private static final int DEFAULT_HEIGHT = 300;
public ResourceTestFrame()
{
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
URL aboutURL = getClass().getResource("about.gif"); //肯定目标文件，加载资源代码
Image img = new ImageIcon(aboutURL).getImage(); //设置图标
setIconImage(img);
JTextArea textArea = new JTextArea();
InputStream stream = getClass().getResourceAsStream("about.txt"); //读取文件
try (Scanner in = new Scanner(stream, "UTF-8"))
{
while (in.hasNext())
textArea.append(in.nextLine() + "\n");
}
add(textArea); //添加到文件区域
}
}
实验输出结果截图为：
测试程序2：
l 在elipse IDE中调试运行ThreadTest，结合程序运行结果理解程序；
l 掌握线程概念；
l 掌握用Thread的扩展类实现线程的方法；
l 利用Runnable接口改造程序，掌握用Runnable接口建立线程的方法。
class Lefthand extends Thread {
public void run()
{
for(int i=0;i<=5;i++)
{ System.out.println("You are Students!");
try{ sleep(500); }
catch(InterruptedException e)
{ System.out.println("Lefthand error.");}
}
}
}
class Righthand extends Thread {
public void run()
{
for(int i=0;i<=5;i++)
{ System.out.println("I am a Teacher!");
try{ sleep(300); }
catch(InterruptedException e)
{ System.out.println("Righthand error.");}
}
}
}
public class ThreadTest
{
static Lefthand left;
static Righthand right;
public static void main(String[] args)
{ left=new Lefthand();
right=new Righthand();
left.start();
right.start();
}
}
使用Runable接口改造后的程序以下：
class Lefthand implements Runnable {
public void run()
{
for(int i=0;i<=5;i++)
{ System.out.println("You are Students!");
try{ Thread.sleep(500);//休眠500毫秒
}
catch(InterruptedException e)
{ System.out.println("Lefthand error.");}
}
}
}
class Righthand implements Runnable {
public void run()
{
for(int i=0;i<=5;i++)
{ System.out.println("I am a Teacher!");
try{ Thread.sleep(300);//休眠300毫秒
}
catch(InterruptedException e)
{ System.out.println("Righthand error.");}
}
}
}
public class ThreadTest
{
public static void main(String[] args)
{
Righthand righthand = new Righthand();//新建一个righthand对象
Lefthand lefthand = new Lefthand();//新建一个lefthand对象
Thread right = new Thread(righthand);//start方法在Thread类中，新建Thread类
right.start();
Thread left=new Thread(lefthand);
left.start();
}
}
程序运行结果以下：
能够经过两种方法实现多线程，分别为：（1）利用Thread类的子类（2）用Runnable()接口实现线程
（1）——定义Thread类的子类并实现用户线程操做，即 run()方法的实现。
——在适当的时候启动线程。
（2）——首先设计一个实现Runnable接口的类；
——而后在类中根据须要重写run方法；
——再建立该类对象，以此对象为参数创建Thread 类的对象；
——调用Thread类对象的start方法启动线程，将 CPU执行权转交到run方法。
测试程序2：
l 在Elipse环境下调试教材625页程序14-一、14-2 、14-3，结合程序运行结果理解程序；
l 在Elipse环境下调试教材631页程序14-4，结合程序运行结果理解程序；
l 对比两个程序，理解线程的概念和用途；
l 掌握线程建立的两种技术。
程序以下：
14-一、14-2 、14-3:
import java.awt.*;
import java.util.*;
import javax.swing.*;
/**
* The component that draws the balls.
* @version 1.34 2012-01-26
* @author Cay Horstmann
*/
public class BallComponent extends JPanel
{
private static final int DEFAULT_WIDTH = 450;
private static final int DEFAULT_HEIGHT = 350;
private java.util.List<Ball> balls = new ArrayList<>();
/**
* Add a ball to the component.
* @param b the ball to add
*/
public void add(Ball b)
{
balls.add(b);
}
public void paintComponent(Graphics g)
{
super.paintComponent(g); // 擦除背景
Graphics2D g2 = (Graphics2D) g;
for (Ball b : balls)
{
g2.fill(b.getShape());
}
}
public Dimension getPreferredSize()
{
return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* Shows an animated bouncing ball.
* @version 1.34 2015-06-21
* @author Cay Horstmann
*/
public class Bounce
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new BounceFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}
/**
* The frame with ball component and buttons.
*/
class BounceFrame extends JFrame
{
private BallComponent comp;
public static final int STEPS = 1000;
public static final int DELAY = 3;
/**
* Constructs the frame with the component for showing the bouncing ball and
* Start and Close buttons
*/
public BounceFrame()
{
setTitle("Bounce");
comp = new BallComponent();
add(comp, BorderLayout.CENTER);//使用边框布局管理器使其显示在窗口中心位置
JPanel buttonPanel = new JPanel();
addButton(buttonPanel, "Start", event -> addBall());//在窗口添加两个按钮
addButton(buttonPanel, "Close", event -> System.exit(0));
add(buttonPanel, BorderLayout.SOUTH);//使用边框布局管理器使其显示在窗口下方位置
pack();
}
/**
* Adds a button to a container.
* @param c the container
* @param title the button title
* @param listener the action listener for the button
*/
public void addButton(Container c, String title, ActionListener listener)
{
JButton button = new JButton(title);
c.add(button);
button.addActionListener(listener);
}
/**
* Adds a bouncing ball to the panel and makes it bounce 1,000 times.
*/
public void addBall()
{
try
{
Ball ball = new Ball();
comp.add(ball);
for (int i = 1; i <= STEPS; i++)
{
ball.move(comp.getBounds());
comp.paint(comp.getGraphics());
Thread.sleep(DELAY);
}
}
catch (InterruptedException e)
{
}
}
}
import java.awt.geom.*;
/**
* A ball that moves and bounces off the edges of a rectangle
* @version 1.33 2007-05-17
* @author Cay Horstmann
*/
public class Ball
{
private static final int XSIZE = 15;
private static final int YSIZE = 15;
private double x = 0;
private double y = 0;
private double dx = 1;
private double dy = 1;
/**
* 将球移动到下一个位置，若是球碰到其中一条边，则反向移动
*/
public void move(Rectangle2D bounds)
{
x += dx;
y += dy;
if (x < bounds.getMinX())
{
x = bounds.getMinX();
dx = -dx;
}
if (x + XSIZE >= bounds.getMaxX())
{
x = bounds.getMaxX() - XSIZE;
dx = -dx;
}
if (y < bounds.getMinY())
{
y = bounds.getMinY();
dy = -dy;
}
if (y + YSIZE >= bounds.getMaxY())
{
y = bounds.getMaxY() - YSIZE;
dy = -dy;
}
}
/**
*获取球在当前位置的形状。
*/
public Ellipse2D getShape()
{
return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}
}
14-4:
package bounceThread;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* Shows animated bouncing balls.
* @version 1.34 2015-06-21
* @author Cay Horstmann
*/
public class BounceThread
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new BounceFrame();
frame.setTitle("BounceThread");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}
/**
* The frame with panel and buttons.
*/
class BounceFrame extends JFrame
{
private BallComponent comp;
public static final int STEPS = 1000;
public static final int DELAY = 5;
/**
* Constructs the frame with the component for showing the bouncing ball and
* Start and Close buttons
*/
public BounceFrame()
{
comp = new BallComponent();
add(comp, BorderLayout.CENTER);//使用边框布局管理器将它放在窗口的中心位置
JPanel buttonPanel = new JPanel();
addButton(buttonPanel, "Start", event -> addBall());
addButton(buttonPanel, "Close", event -> System.exit(0));
add(buttonPanel, BorderLayout.SOUTH);//使用边框布局管理器将它放在窗口的中心位置
pack();
}
/**
* Adds a button to a container.
* @param c the container
* @param title the button title
* @param listener the action listener for the button
*/
public void addButton(Container c, String title, ActionListener listener)
{
JButton button = new JButton(title);
c.add(button);
button.addActionListener(listener);
}
/**
* Adds a bouncing ball to the canvas and starts a thread to make it bounce
*/
public void addBall()
{
Ball ball = new Ball();
comp.add(ball);
Runnable r = () -> {
try
{
for (int i = 1; i <= STEPS; i++)
{
ball.move(comp.getBounds());
comp.repaint();
Thread.sleep(DELAY);
}
}
catch (InterruptedException e)
{
}
};
Thread t = new Thread(r);
t.start();//调用Thread类中的start方法
}
}
package bounceThread;
import java.awt.*;
import java.util.*;
import javax.swing.*;
/**
* The component that draws the balls.
* @version 1.34 2012-01-26
* @author Cay Horstmann
*/
public class BallComponent extends JComponent
{
private static final int DEFAULT_WIDTH = 450;
private static final int DEFAULT_HEIGHT = 350;
private java.util.List<Ball> balls = new ArrayList<>();
/**
* Add a ball to the panel.
* @param b the ball to add
*/
public void add(Ball b)
{
balls.add(b);
}
public void paintComponent(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
for (Ball b : balls)
{
g2.fill(b.getShape());
}
}
public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}
package bounceThread;
import java.awt.geom.*;
/**
A ball that moves and bounces off the edges of a
rectangle
* @version 1.33 2007-05-17
* @author Cay Horstmann
*/
public class Ball
{
private static final int XSIZE = 15;
private static final int YSIZE = 15;
private double x = 0;
private double y = 0;
private double dx = 1;
private double dy = 1;
/**
Moves the ball to the next position, reversing direction
if it hits one of the edges
*/
public void move(Rectangle2D bounds)
{
x += dx;
y += dy;
if (x < bounds.getMinX())
{
x = bounds.getMinX();
dx = -dx;
}
if (x + XSIZE >= bounds.getMaxX())
{
x = bounds.getMaxX() - XSIZE;
dx = -dx;
}
if (y < bounds.getMinY())
{
y = bounds.getMinY();
dy = -dy;
}
if (y + YSIZE >= bounds.getMaxY())
{
y = bounds.getMaxY() - YSIZE;
dy = -dy;
}
}
/**
Gets the shape of the ball at its current position.
*/
public Ellipse2D getShape()
{
return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}
}
三：实验总结 这周主要学习了JAR文件和线程相关的知识，其中线程是程序中一个单一的顺序从控制流程。在学习过程当中，了解了线程建立的两种技术：用Thread类的子类建立线程以及用Runnable()接口实现线程。学习用多线程提升实际运行效率，有效增长了cpu的利用时间，提升计算机工做的效率。对于结对编程，预想的很是好，可是在实际操做过程当中，发现本身还存在着很大的问题。在实验课上老师和学长的帮助后，理解了线程中的优先级。课后本身还会再继续学习。