基本操作文档格式.docx
《基本操作文档格式.docx》由会员分享，可在线阅读，更多相关《基本操作文档格式.docx（19页珍藏版）》请在冰豆网上搜索。
③、线程试图获得一个同步监视器，但更改同步监视器正被其他线程所持有
④、线程在等待某个通知（notify）
⑤、程序调用了线程的suspend方法将线程挂起。
不过该方法容易导致死锁，所以程序应该尽量避免使用该方法。
当线程的run（）方法执行完，或者被强制性地终止，例如出现异常，或者调用了stop（）、desyory（）方法等等，就会从运行状态转变为死亡状态。
4、阻塞状态
处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。
在阻塞状态的线程不能进入就绪队列。
只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。
有三种方法可以暂停Threads执行：
5、死亡状态
当线程的run（）方法执行完，或者被强制性地终止，就认为它死去。
这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。
线程一旦死亡，就不能复生。
如果在一个死去的线程上调用start（）方法，会抛出java.lang.IllegalThreadStateException异常。
二、线程状态的控制
Java提供了一些便捷的方法用于会线程状态的控制。
.
void
destroy（）
已过时。
该方法最初用于破坏该线程，但不作任何清除。
它所保持的任何监视器都会保持锁定状态。
不过，该方法决不会被实现。
即使要实现，它也极有可能以suspend（）
方式被死锁。
如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。
如果另一个线程曾试图锁定该资源，则会出现死锁。
这类死锁通常会证明它们自己是“冻结”的进程。
有关更多信息，请参阅为何不赞成使用Thread.stop、Thread.suspend和Thread.resume？
。
interrupt（）
中断线程。
join（）
等待该线程终止。
join（long
millis）
等待该线程终止的时间最长为
millis
毫秒。
millis,int
nanos）
毫秒+
nanos
纳秒。
resume（）
该方法只与
suspend（）
一起使用，但
已经遭到反对，因为它具有死锁倾向。
setDaemon（boolean
on）
将该线程标记为守护线程或用户线程。
setPriority（int
newPriority）
更改线程的优先级。
static
sleep（long
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
start（）
使该线程开始执行；
Java虚拟机调用该线程的
run
方法。
stop（）
该方法具有固有的不安全性。
用Thread.stop来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查ThreadDeath
异常的一个自然后果）。
如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。
stop
的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。
目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。
如果目标线程等待很长时间（例如基于一个条件变量），则应使用interrupt
方法来中断该等待。
stop（Throwable
obj）
有关详细信息，请参阅
stop（）。
该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。
suspend（）
该方法已经遭到反对，因为它具有固有的死锁倾向。
如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。
如果重新开始目标线程的线程想在调用resume
之前锁定该监视器，则会发生死锁。
这类死锁通常会证明自己是“冻结”的进程。
yield（）
暂停当前正在执行的线程对象，并执行其他线程。
可以看到很多方法，已经标注为过时的，我们应该尽可能的避免使用它们，而应该重点关注start（）、interrupt（）、join（）、sleep（）、yield（）等直接控制方法，和setDaemon（）、setPriority（）等间接控制方法。
1、线程睡眠——sleep
如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread的sleep方法，从上面可以看到sleep方法有两种重载的形式，但是使用方法一样。
比如，我们想要使主线程每休眠100毫秒，然后再打印出数字：
[cpp]
viewplaincopy
1.public
class
Test1
{
2.
public
void
main（String[]
args）
throws
InterruptedException
3.
for（int
i=0;
i<
100;
i++）{
4.
System.out.println（"
main"
+i）;
5.
Thread.sleep（100）;
6.
}
7.
8.}
可以明显看到打印的数字在时间上有些许的间隔。
注意如下几点问题
①、sleep是静态方法，最好不要用Thread的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。
看下面的例子：
System.out.println（Thread.currentThread（）.getName（））;
MyThread
myThread=new
MyThread（）;
myThread.start（）;
myThread.sleep（1000）;
//这里sleep的就是main线程，而非myThread线程
Thread.sleep（10）;
8.
9.
10.
11.
12.}
②、Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。
但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。
因为使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep（1000）使得线程睡眠1秒，可能结果会大于1秒。
[java]
new
MyThread（）.start（）;
6.}
8.class
extends
Thread
@Override
run（）
for
（int
i
=
0;
<
3;
i++）
12.
System.out.println（this.getName（）+"
线程"
+
"
次执行！
）;
13.
try
14.
Thread.sleep（50）;
15.
catch
（InterruptedException
e）
16.
e.printStackTrace（）;
17.
18.
19.
20.}
看某一次的运行结果：
1.Thread-0线程0次执行！
2.Thread-1线程0次执行！
3.Thread-1线程1次执行！
4.Thread-0线程1次执行！
5.Thread-0线程2次执行！
6.Thread-1线程2次执行！
可以看到，线程0首先执行，然后线程1执行一次，又了执行一次。
可以看到它并不是按照sleep的顺序执行的。
2、线程让步——yield
yield（）方法和sleep（）方法有点相似，它也是Thread类提供的一个静态的方法，它也可以让当前正在执行的线程暂停，让出cpu资源给其他的线程。
但是和sleep（）方法不同的是，它不会进入到阻塞状态，而是进入到就绪状态。
yield（）方法只是让当前线程暂停一下，重新进入就绪的线程池中，让系统的线程调度器重新调度器重新调度一次，完全可能出现这样的情况：
当某个线程调用yield（）方法之后，线程调度器又将其调度出来重新进入到运行状态执行。
实际上，当某个线程调用了yield（）方法暂停之后，优先级与当前线程相同，或者优先级比当前线程更高的就绪状态的线程更有可能获得执行的机会，当然，只是有可能，因为我们不可能精确的干涉cpu调度线程。
yield的用法：
MyThread（"
低级"
1）.start（）;
中级"
5）.start（）;
高级"
10）.start（）;
7.}
9.class
MyThread（String
name,
int
pro）
super（name）;
//
设置线程的名称
this.setPriority（pro）;
设置优先级
30;
System.out.println（this.getName（）
线程第"
if
（i
%
5
==
0）
20.
Thread.yield（）;
21.
22.
23.}
关于sleep（）方法和yield（）方的区别如下：
①、sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。
而yield方法调用后，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。
②、sleep方法声明抛出了InterruptedException，所以调用sleep方法的时候要捕获该异常，或者显示声明抛出该异常。
而yield方法则没有声明抛出任务异常。
③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法来控制并发线程的执行。
3、线程合并——join
线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时，Thread类提供了join方法来完成这个功能，注意，它不是静态方法。
从上面的方法的列表可以看到，它有3个重载的方法：
join（）
当前线程等该加入该线程后面，等待该线程终止。
millis）
当前线程等待该线程终止的时间最长为millis毫秒。
如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度
millis,int
nanos）
等待该线程终止的时间最长为millis毫秒+nanos纳秒。
如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度
例子：
thread=new
thread.start（）;
thread.join
（1）;
//将主线程加入到子线程后面，不过如果子线程在1毫秒时间内没执行完，则主线程便不再等待它执行完，进入就绪状态，等待cpu调度
System.out.println（Thread.currentThread（）.getName（）
10.}
12.class
1000;
19.}
在这个例子中，在主线程中调用thread.join（）;
就是将主线程加入到thread子线程后面等待执行。
不过有时间限制，为1毫秒。
4、线程的优先级
每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。
与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。
只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。
每个线程默认的优先级都与创建它的父线程具有相同的优先级，在默认情况下，main线程具有普通优先级。
Thread类提供了setPriority（intnewPriority）和getPriority（）方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~·
0之间，也可以使用Thread类提供的三个静态常量：
MAX_PRIORITY
=10
MIN_PRIORITY
=1
NORM_PRIORITY
=5
name,int
//设置线程的名称
setPriority（pro）;
//设置线程的优先级
从结果可以看到，一般情况下，高级线程更显执行完毕。
注意一点：
虽然Java提供了10个优先级别，但这些优先级别需要操作系统的支持。
不同的操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级别对应。
所以我们应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设定优先级，这样才能保证程序最好的可移植性。
5、守护线程
守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon（true），则可以将其设置为守护线程。
守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。
还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。
setDaemon方法的详细说明：
publicfinalvoidsetDaemon（booleanon）将该线程标记为守护线程或用户线程。
当正在运行的线程都是守护线程时，Java虚拟机退出。
该方法必须在启动线程前调用。
该方法首先调用该线程的checkAccess方法，且不带任何参数。
这可能抛出SecurityException（在当前线程中）。
参数：
on-如果为true，则将该线程标记为守护线程。
抛出：
IllegalThreadStateException-如果该线程处于活动状态。
SecurityException-如果当前线程无法修改该线程。
1./**
2.*
Java线程：
线程的调度-守护线程
3.*/
4.public
Test
public
升级会员 