如何获取线程状态java（Java线程状态）

本篇文章给大家谈谈如何获取线程状态java，以及Java线程状态对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。 今天给各位分享如何获取线程状态java的知识，其中也会对Java线程状态进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java获取当前线程状态。
• 2、JAVA中，线程有哪五个基本状态？他们之间如何让转化？并简述线程周期。
• 3、java怎么从一个类中获取另一个类中的线程的状态。
• 4、Java回调以及如何获取线程的执行结果
• 5、怎样获取java线程中信息

java获取当前线程状态。

java线程的状态有下面几种状态：
/**
* Thread state for a thread which has not yet started.
*/
NEW,

/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,

/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,

/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul
* <li{@link Object#wait() Object.wait} with no timeout</li
* <li{@link #join() Thread.join} with no timeout</li
* <li{@link LockSupport#park() LockSupport.park}</li
* </ul
*
* <pA thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <ttObject.wait()</tt
* on an object is waiting for another thread to call
* <ttObject.notify()</tt or <ttObject.notifyAll()</tt on
* that object. A thread that has called <ttThread.join()</tt
* is waiting for a specified thread to terminate.
*/
WAITING,

/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul
* <li{@link #sleep Thread.sleep}</li
* <li{@link Object#wait(long) Object.wait} with timeout</li
* <li{@link #join(long) Thread.join} with timeout</li
* <li{@link LockSupport#parkNanos LockSupport.parkNanos}</li
* <li{@link LockSupport#parkUntil LockSupport.parkUntil}</li
* </ul
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;

JAVA中，线程有哪五个基本状态？他们之间如何让转化？并简述线程周期。

java中如何获取线程状态java，每个线程都需经历新生、就绪、运行、阻塞和死亡五种状态，线程从新生到死亡如何获取线程状态java的状态变化称为生命周期。
用new运算符和Thread类或其子类建立一个线程对象后，该线程就处于新生状态。

线程的生命周期，把图转化为文字就是： 

1、线程通过new方法创建，调用start，线程进入就绪状态，等待系统的调度（时间片轮转调度）。当系统调度，进入运行状态。正常结束或者异常退出，进程进入死亡状态。

2、处于运行状态的线程若遇到sleep，则线程进入睡眠状态，不会让出资源锁，sleep结束，线程转为就绪状态，等待系统重新调度。

3、处于运行状态的线程可能在等待io，也可能进入挂起状态。io完成，转为就绪状态。

4、处于运行状态的线程yield，线程转为就绪状态。（yield只让给权限比自己高的）

5、处于运行状态的线程遇到wait，线程处于等待状态，需要notify()/notifyALL来唤醒线程，唤醒后的线程处于锁定状态，获取如何获取线程状态java了“同步锁”，之后，线程才转为就绪状态。处于运行的线程synchronized，加上后 变成同步操作。处于锁定状态，获取了“同步锁”，之后，线程才转为就绪状态。

java怎么从一个类中获取另一个类中的线程的状态。

package a;
class A implements Runnable{
Thread t;
A(){
t=new Thread(this);
t.start();
}
@Override
public void run() {
for (int i=1;i<=3;i++){
try {
Thread.sleep(1000);
System.out.println(3-i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("线程A停止如何获取线程状态java了");
}
}
class B{
public void show(){
A a =new A();
for (int i=1;i<=10;i++){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(a.t.isAlive());
}
}
}
public class aaaaaaa{

public static void main(String args[]){

B b=new B();
b.show();
}
}

Java回调以及如何获取线程的执行结果

软件模块之间存在调用的接口如何获取线程状态java，从调用方式来看如何获取线程状态java，有同步调用、回调、异步调用这三种方式如何获取线程状态java：

同步调用是是一种阻塞式调用，调用方要等待被调用方执行完毕返回后才能获取调用的执行结果，是一种单向调用。

回调是一种双向调用，调用方在执行被调用方后，被调用方会调用被调用方的接口如何获取线程状态java；

异步调用是一种类似消息或者事件的机制，接口在收到某个消息或发生某事件时，会主动通知客户方，通常使用回调来实现异步调用。

Java回调的必须要素： 
1.雇主类必须有可以被观察者调用的方法A如何获取线程状态java； 
2.观察者必须持有可以调用A的对象的引用。

在实际工作中，我们通常将方法A以interface或者内部类的形式来实现，然后把包含有A的类的对象引用传递到观察者中。

Java中的线程的返回值是void，并且是一个异步执行流，所以我们没有直接的方法来获取线程执行后的结果，即不能直接知道线程何时结束，以及合适去获取线程执行任务后的结果。由于回调的存在，我们可以在线程中以回调的方式通知线程的调用者线程的结束时间，并可以将任务的结果通过回调回送到调用者中。

怎样获取java线程中信息

？ 在进行多线程编程中，比较重要也是比较困难的一个操作就是如何获取线程中的信息。大多数人会采取比较常见的一种方法就是将线程中要返回的结果存储在一个字段中，然后再提供一个获取方法将这个字段的内容返回给该方法的调用者。如以下的ReturnThreadInfo类：package threadtest1;/**** @author shi mingxiang*/public class ReturnThreadInfo extends Thread { private String str; public ReturnThreadInfo() { this.str = "Hello";}public void run(){ this.str = "Hello World!";}public String getThreadInfo(){ return this.str;}} 大家可以看到该类是一个线程类并含有一个初始值为"Hello"的字段str以及一个可以返回str值的方法：getThreadInfo()，而且当这个线程启动后str会被赋于新值:"Hello World!"。现在我想在另外一个类中启动ReturnThreadInfo线程，并通过getThreadInfo()方法获取值为"Hello World!"的变量并打印输出到控制台中。以下给出一个实现该功能的Main类：package threadtest1;/**** @author shi mingxiang*/public class Main{ public Main() {}/*** @param args the command line arguments*/public static void main(String[] args) { ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo(); returnThreadInfo.start(); //创建并启动ReturnThreadInfo线程 System.out.println(returnThreadInfo.getThreadInfo()); //获取并输出returnThreadInfo对象的str的值}} 以上是一个多数熟悉单线程编程的人在第一反应下给出的实现方法。但是该类在运行的时候输出的结果却不是期望的"Hello World!"而是"Hello"，这是由于线程的竞争条件导致的（由于ReturnThreadInfo线程和Main线程的优先级都为5，所以在很大几率上ReturnThreadInfo线程的run()方法还没有运行，Main类就已经运行System.out.println(returnThreadInfo.getThreadInfo())；将"Hello"输出了。具体的原理可以参见另一篇文章："java多线程的几点误区"）。有的人可能会立即想到把ReturnThreadInfo线程的优先级设高些（比如最大的10）就可以returnThreadInfo线程的run()方法先运行完，然后Main类的System.out.println(returnThreadInfo.getThreadInfo())再运行，这样输出的结就一定是期望的"Hello World!"了。这种通过调整线程优先级的方法固然可以在某种程度上解决该问题，但是线程争用CPU运行时间的原理却决不仅仅只是优先级高低的原因（优先级高的线程并不意味着一定比优先级低的线程先运行，只是几率要更大一些）。你并不希望ReturnThreadInfo线程9999次都比Main先运行，却在最关键的一次在Main之后再运行。因此下面给出两种比较常见的获取线程信息的方法： 一、轮询 比较常见的一种解决方案是，让线程类获取方法在结果字段设置之前返回一个标志值。然后主线程定时询问获取方法，看是否返回了标志之外的值。以下给出了具体的实现方法，该方法不断测试str的值是否为"Hello"，如果不为"Hello"才打印输出它。例如：package threadtest1;/**** @author shi mingxiang*/public class Main{ public Main() {}/*** @param args the command line arguments*/public static void main(String[] args) { ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo(); returnThreadInfo.start(); //创建并启动ReturnThreadInfo线程 while(true){ String str = returnThreadInfo.getThreadInfo(); if(!str.equals("Hello")){ System.out.println(returnThreadInfo.getThreadInfo());break;}}}} 二、回调 轮询方法最大的特点是主类Main不断询问线程类是否结束，这实际上大量浪费了运行时间，特别是当线程特别多的时候。因此如果反过来在线程结束时，由线程自己告诉主类Main线程已经结束，然后Main再获取并输出str的值，这样就避免了轮询方法所带来的不必要的系统开销问题。 在具体的实现过程中，线程可以在结束时通过调用主类中的一个方法来实现告知功能，这种方法叫做回调。这样主类Main就可以在等待线程结束时休息，也就不会占用运行线程的时间。下面是修改后的Main类：public class Main{ public Main() {}/*** @param args the command line arguments*/public static void main(String[] args) { // TODO code application logic here ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo(); returnThreadInfo.start();}public static void receiveStr(String str){ System.out.println(str);}} 相比于前面，我们在Main类中添加了一个静态方法receiveStr(String str)，该方法是供线程结束之前调用，通过参数str将要返回的线程信息返回给Main类并输出显示出来。下面是修改后的ReturnThreadInfo类，该类在线程结束前回调了Main.receiveStr方法，通知线程已结束。package threadtest1;/**** @author shi mingxiang*/public class ReturnThreadInfo extends Thread { private String str; public ReturnThreadInfo() { this.str = "Hello";}public void run(){ Main.receiveStr(str); //回调receiveStr方法}} 如果有很多个对象关心线程的返回的信息,线程可以保存一个回调对象列表。某个对象可以通过已经定义的一个对象将自己添加到列表中，表示自己对这些信息的关注。如果有多个类的实例关心这些信息，也可以定义一个interface，在interface中声名回调方法，然后这些类都实现这个接口。其实这是典型的java处理事件的方法，这么做可以使得回调更灵活，可以处理涉及更多线程、对象和类的情况。稍后会给出这种模仿事件处理模型的回调的实现方法。 这种方案虽然能起到作用，但是它做了大量不需要做的工作。 关于如何获取线程状态java和Java线程状态的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 如何获取线程状态java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于Java线程状态、如何获取线程状态java的信息别忘了在本站进行查找喔。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。