传智播客----Java中的关于线程生命周期的方法
|
Java中的关于线程生命周期的方法
package com.zhou.threadoffunction;
/**
* 一、线程的生命周期：
* ---指线程从创建到启动，直至运行结束；
* ---可以通过调用Thread类的相关方法影响线程的运行状态；
* 二、线程的运行状态：
* ---新建(New)：
* 新建状态---当创建了一个Thread对象时，该对象就处于“新建状态”；
* ---没有启动，因此无法运行；
*
* ---可执行(Runnable)：
* 可执行状态---其他线程调用了处于新建状态的线程的start方法，该线程对象将转换到“可执行状态”；
* ---线程拥有获得CPU控制权的机会，处于等待调度阶段；
*
* ---运行(Running)
* 运行状态---处在“可执行状态”的线程对象一旦获得了CPU的控制权，就会转换到“执行状态”；
* ---在“执行状态”下，线程状态占用CPU时间片段，执行run方法中的代码；
* ---处在“执行状态”下的线程可以调用yield()方法，该方法用于主动出让CPU的控制权。
* 线程对象出让CPU的控制权后，回到“可执行状态”，重新等待调度；
*
* ---阻塞(Blocking)：
* 阻塞状态---线程在“执行状态”下由于受某种条件的影响被迫让出CPU的控制权，进入“阻塞状态”。
* ---进入阻塞状态的三种情况有：
* 1.调用sleep(long mills)方法；
* 2.调用join()方法(合并某个线程)：在一个线程调用另外的一个线程的join()方法，将使得当前线程阻塞，等待另外这个线程执行完成后再进入可执行状态；
* --处在“执行状态”的线程如果调用了其他线程的join方法，将被挂起进入“阻塞状态”；
* --目标线程执行完毕后才会解除阻塞，回到“可执行状态”；
* 解除阻塞：
* --睡眠状态超时；
* --调用join后等待其他线程执行完毕；
* --I/O操作执行完毕；
* --调用阻塞线程的interrupt方法(线程睡眠时，调用该线程的interrupt方法会抛出InterruptedException)
*
* 3.执行I/O操作：
* --线程在执行过程中如果因为访问外部资源（等待用户键盘输入、访问网络）时发生了阻塞，也会导致当前线程进入“阻塞状态”；
*
* ---死亡(Dead)
* 死亡状态：处于“执行状态”的线程一旦从run方法返回（无论是正常退出还是抛出异常）就会进入“死亡状态”；
* 已经进入“死亡”的线程是不能重新运行的，否则会抛出LllegalThreadStateException；
* 可以使用Thread类的isAlive()方法判断线程是否活着；
*
* 三、线程的调度：
* --按照特定机制为线程分配CPU时间片段的行为；
* --Java程序运行时，由java虚拟机负责线程的调度；
* 线程调度的实现方式：
* --分时调度模型：让所有线程轮流获得cpu的控制权，且每个线程平均分配cpu时间片段；
* --抢占式调度模型：选择优先级相对较高的线程执行，如果所有线程的优先级相同，则随机选择一个线程执行，java虚拟机就是采用这种调度模型；
* 线程的优先级：
* Thread类提供了获取和设置线程优先级的方法：
* --getPriority：获取当前线程的优先级；
* --setPriority：设置当前线程的优先级；
* java语言为线程设置了10个优先级，分别使用1到10内的整数表示，整数值越大代表优先级越高。每个线程都有一个默认的优先级， 主线程的默认优先级是5；
* Thread类定义的桑常量分别代表了几个常用的优先级：
* ---MAX_PRIORITY:代表了最高优先级10；
* ---MIN_PRIORITY:代表了最低优先级1；
* ---NORM_PRIORITY：代表了正常优先级5；
* setPriority这个方法不一定起作用，在不同的操作系统、不同的JVM上，效果可能不同；操作系统也不能保证设置了优先级的线程就一定会先运行或得到更多的CPU时间；
* 在实际使用中，不建议使用setPriority这个方法；
*
*
*
* @author Administrator
*
*/
public class
FunctionOfThread extends Thread{
public static void main(String[] args) {
//创建两个线程；
Thread thread1 = new FunctionOfThread("线程-1");
Thread thread2 = new FunctionOfThread("线程-2");
//启动线程；
thread1.start();
thread2.start();
}
//为了能够写得清楚一点，我们写一个构造器给线程起名字；
public FunctionOfThread(String threadName) {
super(threadName);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
//当前线程的名字加i
//当i等于10的时候让当前线程让出CPU的控制权而处于“可执行状态”；
if(i == 10){
yield();
//使得当前线程让出Cpu的控制权而处于“可执行”状态的方法；
}
}
}
}
package com.zhou.threadoffunction;
public class JoinThread extends Thread{
public static void main(String[] args) {
//创建一个线程；
Thread thread = new JoinThread();
//启动线程；
thread.start();
//然后我在主线程里面也写一个循环；
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
//我让当i等于10的时候，让出CPU的控制权进入到“阻塞状态”；
if(i == 10){
try {
thread.join();
//也就是其他线程进入了执行状态，而主线程就被挂起进入到了阻塞状态；
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
}
}
}
package com.zhou.threadoffunction;
public class
ThreadOfSleep extends Thread {
public static void main(String[] args) {
//创建并启动线程；
new ThreadOfSleep().start();
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//我使当前线程停一会再打印；
try {
Thread.sleep(1000);
//每隔1秒打印一次；这个时候这个线程每次要阻塞1秒才打印，所以这个时候叫阻塞状态；
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":" + i);
}
}
}
package com.zhou.threadoffunction;
public class InterruptThread extends Thread{
public static void main(String[] args) {
//创建线程；
Thread thread = new InterruptThread();
//启动线程；
thread.start();
//打断当前线程的休眠,解除线程的阻塞状态；
thread.interrupt();
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
//当i等于10，我让当前线程睡眠很长一段时间，让线程处于阻塞状态；
if(i == 10){
try {
Thread.sleep(1000000000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
package com.zhou.threadoffunction;
public class
IsAliveThread extends Thread{
public static void main(String[] args) {
Thread thread = new IsAliveThread();
//还没有启动线程的时候看看这个线程的状态是不是活着的；
System.out.println(thread.isAlive());//false;
thread.start();
//启动了线程之后来看看这个线程是不是活着的；
System.out.println(thread.isAlive());//true;
//如果我想看thread这个线程执行完了之后，这个线程的状态，我就先让这个thread线程执行完，调用这个线程的join方法；
try {
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//然后我再来看这个线程是不是活着的；
System.out.println(thread.isAlive());//false;
//thread这个线程已经结束了，我在调用start()方法
//
thread.start();//这个时候就会抛异常；
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
}
}
}
package com.zhou.threadoffunction;
public class
PriorityOfThread extends Thread{
public static void main(String[] args) {
//直接创建两个线程；
Thread thread1 = new PriorityOfThread("线程-1");
Thread thread2 = new PriorityOfThread("线程-2");
//首先来打印一下这三个线程的优先级；
System.out.println(thread1.getPriority());
//5
System.out.println(thread2.getPriority());
//5
System.out.println(Thread.currentThread().getPriority());
//当前线程的优先级；//5
//设置线程的优先级；
thread1.setPriority(MIN_PRIORITY);
thread2.setPriority(MAX_PRIORITY);
//启动线程；
thread1.start();
thread2.start();
//让当前主线程也执行一段代码；
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
//为了看得清楚一点，给线程起名字；
public PriorityOfThread(String threadName) {
super(threadName);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
}
}
}
|
本文出自 “IT技术JAVA” 博客，转载请与作者联系！