Java スレッドのライフサイクルと状態制御の詳細な図による説明
- 黄舟オリジナル
- 2017-05-21 10:25:212068ブラウズ
この記事では、主に Java スレッドの ライフ サイクル と ステータス 制御について説明します。必要な方は、
1. スレッド ライフ サイクル
スレッド状態遷移図:
を参照してください。 1. 新しい状態
new キーワードと Thread クラスまたはそのサブクラスを使用してスレッド オブジェクト を作成すると、スレッド オブジェクトは新しい状態になります。新しい状態のスレッドは独自のメモリ空間を持ち、start メソッドを呼び出すことで準備完了状態 (実行可能) になります。
注: start() メソッドは、すでに開始されているスレッドで再度呼び出すことはできません。そうしないと、Javalang.IllegalThreadStateException 例外が発生します。
2. Ready状態
Ready状態のスレッドは、実行条件は整っていますが、まだCPUに割り当てられておらず、スレッドreadyqueue内にあります(形式は異なりますが)キュー。実際には、実行可能キューではなく実行可能プールと呼ばれます (CPU スケジューリングは必ずしも先入れ先出し順序でスケジュールされるわけではないため)。システムが CPU を割り当てるのを待ちます。待機状態は実行状態ではありません。システムが実行を待機している Thread オブジェクトを選択すると、システムが選択したアクションは「CPU スケジューリング」と呼ばれます。 CPU を取得すると、スレッドは実行状態になり、自動的に独自の run メソッドを呼び出します。
ヒント: start() メソッドを呼び出した直後にサブスレッドを実行したい場合は、Thread.sleep() メソッドを使用してメインスレッドをしばらくスリープさせてからサブスレッドを実行できます。
3. 実行状態
実行状態のスレッドは、ブロックされたり、準備完了になったり、停止したりする可能性があります。準備完了状態のスレッドが CPU によってスケジュールされた場合、スレッドは準備完了状態から実行状態に変化し、run() メソッド内のタスクを実行します。スレッドが CPU リソースを失うと、スレッドは実行状態から準備完了状態に変わります。システムがリソースを再度割り当てるまで待ちます。実行中のスレッドで yield() メソッドを呼び出すこともできます。これにより、CPU リソースが解放され、再び準備が整います。
以下のことが起こると、スレッドは実行状態からブロッキング状態に変わります:
①. スレッドは占有されているシステムリソースを積極的に放棄するためにスリープメソッドを呼び出します
②。このメソッドでは、戻る前にスレッドがブロックされました
③、スレッドは同期モニターを取得しようとしましたが、変更同期モニターは他のスレッドによって保持されていました
④、スレッドは通知を待っていました(そうではありません) ify)
⑤. プログラムはスレッドのsuspendメソッドを呼び出してスレッドを一時停止します。ただし、この方法ではデッドロックが発生しやすいため、プログラムではこの方法の使用を避ける必要があります。
スレッドのrun()メソッドが実行されたり、例外が発生したり、stop()、desired()メソッドなどが呼び出されるなど強制終了された場合、実行状態から遷移します。死の状態へ。
4. ブロック状態
実行状態のスレッドは、sleep (スリープ) メソッドの実行や、I などのリソースの待機などの特定の状況下で、CPU を放棄し、自身のスレッドを一時的に停止します。 /O デバイスを実行し、ブロック状態に入ります。
ブロック状態のスレッドは準備完了キューに入ることができません。スリープ時間が経過した、または待機中の I/O デバイスがアイドル状態になったなど、ブロッキングの原因が解消された場合にのみ、スレッドは準備完了状態になり、準備完了キューに再度キューに入れられ、元の停止位置から開始されます。システムによって選択された後、実行を続けます。
5. 停止状態
スレッドの run() メソッドが実行されるか強制終了されると、停止したとみなされます。このスレッド オブジェクトは生きている可能性がありますが、個別に実行されるスレッドではなくなります。スレッドが終了すると、復活することはできません。 start() メソッドがデッドスレッドで呼び出された場合、java.lang.IllegalThreadStateException 例外がスローされます。
2. スレッドステータスの制御
Java には、スレッドステータスを制御するための便利なメソッドがいくつか用意されています。
.
多くのメソッドが廃止済みとしてマークされていることがわかりますが、それらの使用はできる限り避けるべきですが、start()、interrupt()、join()、sleep()、yield() に重点を置く必要があります。など。直接制御メソッドと、setDaemon() や setPriority() などの間接制御メソッドがあります。
1. スレッドのスリープ - スリープ
現在実行中のスレッドを一定期間一時停止してブロック状態に入る必要がある場合は、Thread の sleep メソッドを呼び出すことができます。 sleep メソッドには 2 つの形式のオーバーロードがありますが、使用方法は同じです。
たとえば、メインスレッドを 100 ミリ秒ごとにスリープさせてから、数値を出力したいとします。
public class Test {
public static void main(String[] args) throws InterruptedException {
for(int i=;i<;i++){
System.out.println("main"+i);
Thread.sleep();
}
}
}明らかに、出力された数値の間にはわずかな時間のギャップがあることがわかります。
以下の問題に注意してください
①. sleep は static メソッドです。これは常に実行中のスレッドをスリープさせるためです。を呼び出すと、スレッド オブジェクトの実行にのみ有効です。次の例を見てください:
public class Test1 {
public static void main(String[] args) throws InterruptedException {
System.out.println(Thread.currentThread().getName());
MyThread myThread=new MyThread();
myThread.start();
myThread.sleep(1000);//这里sleep的就是main线程，而非myThread线程
Thread.sleep(10);
for(int i=0;i<100;i++){
System.out.println("main"+i);
}
}
}②. Java スレッドのスケジューリングは Java マルチスレッドの核心であり、システムのパフォーマンスを最大限に発揮し、プログラムの実行効率を向上させることができます。ただし、プログラマがスケジュールをどのように記述しても、スレッドの実行順序に最大限の影響を与えるだけで、正確な制御を達成することはできません。スリープ メソッドを使用した後、スレッドはスリープ時間が経過した場合にのみ、準備完了状態に戻ります。準備完了状態から実行状態への移行はシステムによって制御されます。したがって、Thread.sleep(1000) を呼び出してスレッドを 1 秒間スリープさせると、結果は 1 秒を超える可能性があります。
public class Test1 {
public static void main(String[] args) throws InterruptedException {
new MyThread().start();
new MyThread().start();
}
}
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(this.getName()+"线程" + i + "次执行！");
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}特定の操作の結果を見てください:
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 が 1 回実行され、その後再度実行されることがわかります。スリープの順に実行されていないことがわかります。
2. スレッドの収量 - yield
yield() メソッドは、Thread クラスによって提供される静的メソッドでもあり、現在実行中のスレッドを一時停止することもできます。 CPU リソースを他のスレッドに与えます。ただし、sleep() メソッドとは異なり、ブロッキング状態にはならず、準備完了状態になります。 yield() メソッドは現在のスレッドを一時停止し、準備ができたスレッド プールに再び入り、システムのスレッド スケジューラにスレッドを再スケジュールさせるだけです。この状況が発生する可能性は十分にあります。スレッドが yield() メソッドを呼び出すと、スレッド スケジューラはそれをスケジュールし、実行のために実行状態に戻ります。
実際、スレッドが一時停止するために yield() メソッドを呼び出すと、現在のスレッドと同じ優先度を持つスレッド、または準備完了状態にある現在のスレッドよりも高い優先度を持つスレッドが、一時停止する可能性が高くなります。もちろん、CPU スケジューリング スレッドに正確に干渉することはできないため、可能であるだけです。
yield の使用法:
public class Test1 {
public static void main(String[] args) throws InterruptedException {
new MyThread("低级", 1).start();
new MyThread("中级", 5).start();
new MyThread("高级", 10).start();
}
}
class MyThread extends Thread {
public MyThread(String name, int pro) {
super(name);// 设置线程的名称
this.setPriority(pro);// 设置优先级
}
@Override
public void run() {
for (int i = 0; i < 30; i++) {
System.out.println(this.getName() + "线程第" + i + "次执行！");
if (i % 5 == 0)
Thread.yield();
}
}
}sleep() メソッドと yield() メソッドの違いは次のとおりです:
① sleep メソッドは現在のスレッドを一時停止した後、ブロッキング状態に入ります。スリープ時間が経過した場合にのみ、準備完了状態になります。 yield メソッドは呼び出された後、すぐに準備完了状態になるため、準備完了状態になった直後に実行状態にスケジュールされる可能性があります。
②. sleepメソッドはInterruptedExceptionをスローすることを宣言しているため、sleepメソッドを呼び出す際には例外をキャッチするか、例外をスローすることを明示的に宣言する必要があります。 yield メソッドは、タスク例外をスローすることを宣言しません。
③. 通常、sleep メソッドは、yield メソッドよりも移植性が優れています。同時スレッドの実行を制御するために、yield メソッドに依存しないでください。
3. スレッドのマージ - join
スレッドのマージの意味は、実行のために複数の並列スレッドを 1 つのスレッドにマージすることです。アプリケーションのシナリオでは、1 つのスレッドが実行を完了する前に別のスレッドの実行を待つ必要があります。 Thread クラスは、この関数を完了するための join メソッドを提供します。これは静的メソッドではないことに注意してください。
上記のメソッドのリストからわかるように、これには 3 つのオーバーロードされたメソッドがあります:
void join()
現在のスレッドはこのスレッドの後ろに参加し、スレッドが終了するのを待つ必要があります。
void join(long millis)
当前线程等待该线程终止的时间最长为 millis 毫秒。 如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度
void join(long millis,int nanos)
等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度
例子：
public class Test1 {
public static void main(String[] args) throws InterruptedException {
MyThread thread=new MyThread();
thread.start();
thread.join(1);//将主线程加入到子线程后面，不过如果子线程在1毫秒时间内没执行完，则主线程便不再等待它执行完，进入就绪状态，等待cpu调度
for(int i=0;i<30;i++){
System.out.println(Thread.currentThread().getName() + "线程第" + i + "次执行！");
}
}
}
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(this.getName() + "线程第" + i + "次执行！");
}
}
}在这个例子中，在主线程中调用thread.join(); 就是将主线程加入到thread子线程后面等待执行。不过有时间限制，为1毫秒。
4、线程的优先级
每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。
每个线程默认的优先级都与创建它的父线程具有相同的优先级，在默认情况下，main线程具有普通优先级。
Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~•0之间，也可以使用Thread类提供的三个静态常量：
MAX_PRIORITY =10
MIN_PRIORITY =1
NORM_PRIORITY =5
例子：
public class Test1 {
public static void main(String[] args) throws InterruptedException {
new MyThread("高级", 10).start();
new MyThread("低级", 1).start();
}
}
class MyThread extends Thread {
public MyThread(String name,int pro) {
super(name);//设置线程的名称
setPriority(pro);//设置线程的优先级
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(this.getName() + "线程第" + i + "次执行！");
}
}
}从结果可以看到 ，一般情况下，高级线程更显执行完毕。
注意一点：虽然Java提供了10个优先级别，但这些优先级别需要操作系统的支持。不同的操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级别对应。所以我们应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设定优先级，这样才能保证程序最好的可移植性。
5、守护线程
守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。
守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。
setDaemon方法的详细说明：
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。 该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。
参数：
on - 如果为 true，则将该线程标记为守护线程。
抛出：
IllegalThreadStateException - 如果该线程处于活动状态。
SecurityException - 如果当前线程无法修改该线程。
/**
* Java线程：线程的调度-守护线程
*/
public class Test {
public static void main(String[] args) {
Thread t1 = new MyCommon();
Thread t2 = new Thread(new MyDaemon());
t2.setDaemon(true); //设置为守护线程
t2.start();
t1.start();
}
}
class MyCommon extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("线程1第" + i + "次执行！");
try {
Thread.sleep(7);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MyDaemon implements Runnable {
public void run() {
for (long i = 0; i < 9999999L; i++) {
System.out.println("后台线程第" + i + "次执行！");
try {
Thread.sleep(7);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}执行结果：
1. 后台线程第0次执行！
2. 线程1第0次执行！
3. 线程1第1次执行！
4. 后台线程第1次执行！
5. 后台线程第2次执行！
6. 线程1第2次执行！
7. 线程1第3次执行！
8. 后台线程第3次执行！
9. 线程1第4次执行！
10. 后台线程第4次执行！
11. 后台线程第5次执行！
12. 后台线程第6次执行！
13. 后台线程第7次执行！
从上面的执行结果可以看出：前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。
实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。
守护线程的用途：
守护线程通常用于执行一些后台作业，例如在你的应用程序运行时播放背景音乐，在文字编辑器里做自动语法检查、自动保存等功能。Java的垃圾回收也是一个守护线程。守护线的好处就是你不需要关心它的结束问题。例如你在你的应用程序运行的时候希望播放背景音乐，如果将这个播放背景音乐的线程设定为非守护线程，那么在用户请求退出的时候，不仅要退出主线程，还要通知播放背景音乐的线程退出；如果设定为守护线程则不需要了。
6、如何结束一个线程
Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit这些终止线程运行的方法已经被废弃了，使用它们是极端不安全的！想要安全有效的结束一个线程，可以使用下面的方法。
1、正常执行完run方法，然后结束掉
2、控制循环条件和判断条件的标识符来结束掉线程
比如说run方法这样写：
class MyThread extends Thread {
int i=0;
@Override
public void run() {
while (true) {
if(i==10)
break;
i++;
System.out.println(i);
}
}
}或者
class MyThread extends Thread {
int i=0;
boolean next=true;
@Override
public void run() {
while (next) {
if(i==10)
next=false;
i++;
System.out.println(i);
}
}
}或者
class MyThread extends Thread {
int i=0;
@Override
public void run() {
while (true) {
if(i==10)
return;
i++;
System.out.println(i);
}
}
}只要保证在一定的情况下，run方法能够执行完毕即可。而不是while(true)的无线循环。
3、使用interrupt结束一个线程。
诚然，使用第2中方法的标识符来结束一个线程，是一个不错的方法，但是如果，该线程是处于sleep、wait、join的状态的时候，while循环就不会执行，那么我们的标识符就无用武之地了，当然也不能再通过它来结束处于这3种状态的线程了。
可以使用interrupt这个巧妙的方式结束掉这个线程。
我们看看sleep、wait、join方法的声明：
public final void wait() throws InterruptedException public static native void sleep(long millis) throws InterruptedException public final void join() throws InterruptedException
可以看到，这三者有一个共同点，都抛出了一个InterruptedException的异常。
在什么时候会产生这样一个异常呢？
每个Thread都有一个中断状状态，默认为false。可以通过Thread对象的isInterrupted()方法来判断该线程的中断状态。可以通过Thread对象的interrupt()方法将中断状态设置为true。
当一个线程处于sleep、wait、join这三种状态之一的时候，如果此时他的中断状态为true，那么它就会抛出一个InterruptedException的异常，并将中断状态重新设置为false。
看下面的简单的例子：
public class Test1 {
public static void main(String[] args) throws InterruptedException {
MyThread thread=new MyThread();
thread.start();
}
}
class MyThread extends Thread {
int i=1;
@Override
public void run() {
while (true) {
System.out.println(i);
System.out.println(this.isInterrupted());
try {
System.out.println("我马上去sleep了");
Thread.sleep(2000);
this.interrupt();
} catch (InterruptedException e) {
System.out.println("异常捕获了"+this.isInterrupted());
return;
}
i++;
}
}
}测试结果：
1. 1
2. false
3. 我马上去sleep了
4. 2
5. true
6. 我马上去sleep了
7. 异常捕获了false
可以看到，首先执行第一次while循环，在第一次循环中，睡眠2秒，然后将中断状态设置为true。当进入到第二次循环的时候，中断状态就是第一次设置的true，当它再次进入sleep的时候，马上就抛出了InterruptedException异常，然后被我们捕获了。然后中断状态又被重新自动设置为false了（从最后一条输出可以看出来）。
所以，我们可以使用interrupt方法结束一个线程。具体使用如下：
public class Test1 {
public static void main(String[] args) throws InterruptedException {
MyThread thread=new MyThread();
thread.start();
Thread.sleep(3000);
thread.interrupt();
}
}
class MyThread extends Thread {
int i=0;
@Override
public void run() {
while (true) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("中断异常被捕获了");
return;
}
i++;
}
}
}多测试几次，会发现一般有两种执行结果：
0
1
2
4. 中断异常被捕获了
或者
0
1
2
3
5. 中断异常被捕获了
这两种结果恰恰说明了 只要一个线程的中断状态一旦为true，只要它进入sleep等状态，或者处于sleep状态，立马回抛出InterruptedException异常。
第一种情况，是当主线程从3秒睡眠状态醒来之后，调用了子线程的interrupt方法，此时子线程正处于sleep状态，立马抛出InterruptedException异常。
最初の状況は、メインスレッドが 3 秒のスリープ状態から復帰し、サブスレッドの割り込みメソッドを呼び出すときです。この時点では、サブスレッドはまだスリープ状態になっていません。次に、3 番目の while ループ中にスリープ状態に入り、すぐに InterruptedException をスローします。
以上がJava スレッドのライフサイクルと状態制御の詳細な図による説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。