java获取线程状态

Ⅰ java中线程的几种可用状态有哪些请大家解释一下。

线程在执行过程中，可以处于下面几种状态：
1、就绪(Runnable):线程准备运行，不一定立马就能开始执行。
2、运行中(Running)：进程正在执行线程的代码。
3、等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
4、睡眠中(Sleeping)：线程被强制睡眠。
5、I/O阻塞(BlockedonI/O)：等待I/O操作完成。
6、同步阻塞(BlockedonSynchronization)：等待获取锁。
7、死亡(Dead)：线程完成了执行。

Ⅱ 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 e 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>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.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 e 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 线程的5种状态：

1、新建(new)

新建一个线程的对象。

2、可运行(runable)

线程对象创建后，其他线程调用该线程的start方法。或者该线程位于可运行线程池中等待被线程调用，已获取cpu的使用权。

3、运行(running)

可运行的线程获取了cpu的使用权，执行程序代码

4、阻塞(block)

由于某些原因该线程放弃了cpu的使用权。停止执行。除非线程进入可运行的状态，才会有机会获取cpu的使用权。

（1）等待阻塞：运行中的线程执行wait方法，这时候该线程会被放入等待队列。

（2）同步阻塞：运行中的线程获取同步锁，如果该同步锁被别的线程占用，这个线程会成被放入锁池，等待其他线程释放同步锁。

（3）其他阻塞：运行的线程执行sleep或者join方法这个线程会成为阻塞状态。当sleep超时，join等待线程终止，该线程会进入可运行状态。

5、死亡(dead)

线程run mian 执行完毕后，或者因为某些异常产生退出了 run 方法，该线程的生命周期结束。

Ⅳ java获得当前线程有两种方法，第一种是Thread.currentThread();谁知道另外一种

另外一种是实现Runnable接口，implements Runnable
这种方法有两个好处是
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承特性带来的局限。经常碰到这样一种情况，即当要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

Ⅳ java线程中的几种状态以及相互转换

• NEW:线程创建之后，但是还没有启动(notyetstarted)。

• RUNNABLE:正在Java虚拟机下跑任务的线程的状态。在RUNNABLE状态下的线程可能会处于等待状态，因为它正在等待一些系统资源的释放，比如IO

• BLOCKED:阻塞状态，等待锁的释放，比如线程A进入了一个synchronized方法，线程B也想进入这个方法，但是这个方法的锁已经被线程A获取了，这个时候线程B就处于BLOCKED状态

• WAITING:等待状态，处于等待状态的线程是由于执行了3个方法中的任意方法。1.Object的wait方法，并且没有使用timeout参数;2.Thread的join方法，没有使用timeout参数3.LockSupport的park方法。处于waiting状态的线程会等待另外一个线程处理特殊的行为。再举个例子，如果一个线程调用了一个对象的wait方法，那么这个线程就会处于waiting状态直到另外一个线程调用这个对象的notify或者notifyAll方法后才会解除这个状态

• TIMED_WAITING:有等待时间的等待状态，比如调用了以下几个方法中的任意方法，并且指定了等待时间，线程就会处于这个状态。1.Thread.sleep方法2.Object的wait方法，带有时间3.Thread.join方法，带有时间4.LockSupport的parkNanos方法，带有时间5.LockSupport的parkUntil方法，带有时间

• TERMINATED:线程中止的状态，这个线程已经完整地执行了它的任务

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

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

Ⅶ 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停止了");
}
}
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();
}
}