Java 线程优先级

概要:

每个线程都有一个“优先级”,优先级可以用整数表示,取值范围为0~10,0为最低优先级,10为最高优先级,当决定哪个线程需要调度时,首先查看是否存在优先级高的可调度线程,如果存在,就从中选择进行调度。当该线程的时间片到达之后,系统查看是否存在另一个优先级为比较高的可调度线程,如果存在就调度。这样依次进行判断调度线程。本实例利用三种方式实现线程的优先级排列家族的等级。

| |目录

技术要点

    实现线程优先级的技术要点如下:

  • Thread类有三个优先级静态常量:MAX_PRIORITY取值是10,为线程最高优先级;MIN_PRIORITY取值是1,为线程最低优先级;NORM_PRIORITY取值是5。为线程中间位置的优先级。默认情况下,线程的优先级为NORM_PRIORITY。

  • Java中的线程在同等情况下,对于两个同时启动的线程,优先级高的线程先获取CPU资源,先被真正运行,优先级低的线程后获取CPU资源,后被执行。

  • 对于两个同时启动的线程,大多数情况下优先级高的线程会比优先级低的线程先运行,但也有例外情况,完全取决于Java虚拟机的调度。

代码实现

package net.xsoftlab.baike;
class OneFamilyThread implements Runnable { // 线程实现接口Runnable
	Thread thread; // 声明一个线程
	OneFamilyThread() {
	} // 默认构造方法
	OneFamilyThread(String name) { // 构造方法初始一个线程
		thread = new Thread(this, name);
	}
	public void run() {
		System.out.println("家族人员:" + thread.getName()); // 获得线程的名称
	}
	public void startThreadByLevel() { // 按优先级执行线程
		OneFamilyThread o1 = new OneFamilyThread("爷爷");// 创建线程对象并命名
		OneFamilyThread o2 = new OneFamilyThread("奶奶");
		OneFamilyThread o3 = new OneFamilyThread("爸爸");
		OneFamilyThread o4 = new OneFamilyThread("妈妈");
		OneFamilyThread o5 = new OneFamilyThread("我");
		o1.thread.setPriority(Thread.MAX_PRIORITY); // MAX_PRIORITY优先级最大
		o2.thread.setPriority(Thread.MAX_PRIORITY - 1); // 较次之
		o3.thread.setPriority(Thread.NORM_PRIORITY); // NORM_PRIORITY处于中间位置
		o4.thread.setPriority(Thread.NORM_PRIORITY - 1);
		o5.thread.setPriority(Thread.MIN_PRIORITY); // MIN_PRIORITY优先级最小
		o1.thread.start(); // 启动线程
		o2.thread.start();
		o3.thread.start();
		o4.thread.start();
		o5.thread.start();
		try {
			o5.thread.join(); // 等待线程运行结束
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("等待线程结束出错:" + e.getMessage());
		}
	}
}
class TwoFamilyThread implements Runnable {
	Thread thread;
	public TwoFamilyThread() {
	} // 默认构造方法
	public void run() {
		System.out.println("家族人员:" + thread.getName()); // 获得线程的名称
	}
	public void startThreadByLevel() { // 按优先级执行线程
		TwoFamilyThread t1 = new TwoFamilyThread(); // 创建线程类
		TwoFamilyThread t2 = new TwoFamilyThread();
		TwoFamilyThread t3 = new TwoFamilyThread();
		TwoFamilyThread t4 = new TwoFamilyThread();
		TwoFamilyThread t5 = new TwoFamilyThread();
		t1.thread = new Thread(t1, "爷爷"); // 线程类赋名称
		t2.thread = new Thread(t2, "奶奶");
		t3.thread = new Thread(t3, "爸爸");
		t4.thread = new Thread(t4, "妈妈");
		t5.thread = new Thread(t5, "我");
		t1.thread.setPriority(10); // 线程优先级10为优先级最高 t2.thread.setPriority(9);
		t3.thread.setPriority(8);
		t4.thread.setPriority(7);
		t5.thread.setPriority(6);
		t1.thread.start(); // 启动线程
		t2.thread.start();
		t3.thread.start();
		t4.thread.start();
		t5.thread.start();
		try {
			t5.thread.join(); // 等待线程运行结束
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("等待线程结束出错:" + e.getMessage());
		}
	}
}
class ThreeFamilyThread extends Thread {
	Thread thread;
	public ThreeFamilyThread() {
	} // 默认构造方法
	public ThreeFamilyThread(String name) { // 带参数构造方法初始一个线程
		thread = new Thread(this, name);
	}
	public void run() {
		System.out.println("家族人员:" + thread.getName()); // 获得线程的名称
	}
	public void startThreadByLevel() { // 按优先级执行线程
		ThreeFamilyThread e1 = new ThreeFamilyThread("爷爷");// 创建线程对象并命名
		ThreeFamilyThread e2 = new ThreeFamilyThread("奶奶");
		ThreeFamilyThread e3 = new ThreeFamilyThread("爸爸");
		ThreeFamilyThread e4 = new ThreeFamilyThread("妈妈");
		ThreeFamilyThread e5 = new ThreeFamilyThread("我");
		e1.thread.setPriority(Thread.MAX_PRIORITY); // MAX_PRIORITY优先级最大
		e2.thread.setPriority(Thread.MAX_PRIORITY - 1); // 较次之
		e3.thread.setPriority(Thread.NORM_PRIORITY); // NORM_PRIORITY处于中间位置
		e4.thread.setPriority(Thread.NORM_PRIORITY - 1);
		e5.thread.setPriority(Thread.MIN_PRIORITY); // MIN_PRIORITY优先级最小
		e1.thread.start(); // 启动线程
		e2.thread.start();
		e3.thread.start();
		e4.thread.start();
		e5.thread.start();
		try {
			e5.thread.join(); // 等待线程运行结束
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("等待线程结束出错:" + e.getMessage());
		}
	}
}
public class TextPriorityLevel extends Thread { // 操作运用优先级实现家庭等的类
	public static void main(String[] args) { // java程序主入口处
		System.out.println("继承Thread类,根据数字从高到低实现线程优先级");
		new TwoFamilyThread().startThreadByLevel();
		System.out.println("继承Thread类,根据静态等级常量实现线程优先级");
		new ThreeFamilyThread().startThreadByLevel();
		System.out.println("实现Runnable接口,根据静态等级常量实现线程优先级");
		new OneFamilyThread().startThreadByLevel();
	}
}

程序解读

  1. OneFamilyThread类实现Runnable接口可看作是一线程类,实现该接口必须实现run()方法,该类的startThreadByLevel()方法创建5个线程,并对每个线程设置优先级。其中Thread类的MAX_PRIORITY表示优先级最高,NORM_PRIORITY表示优先级居中,MIN_PRIORITY表示优先级最小。启动线程,线程是按照优先级的不同依次启动运行。

  2. TwoFamilyThread类实现Runnable接口可看作是一线程类,实现该接口必须实现run()方法,类中的startThreadByLevel()方法创建5个线程,每个线程设置优先级。其中setPriority(整数)方法是以数字设置优先级,10表示优先级最高,优先级依次类推,1表示优先级最低。启动线程,线程是按照优先级的不同依次启动运行。

  3. ThreeFamilyThread类继承Thread线程类,扩展run()方法。startThreadByLevel()方法创建5个线程类,并设置5个线程的优先级,方式与OneFamilyThread类的该方法相同。启动线程,线程是按照优先级的不同依次启动运行。

  4. 每个类中都含有join()方法,该方法是等待前面的线程运行结束才运行该方法后的线程。


评论关闭
评论 还能输入200
评论关闭
评论 还能输入200
  • 全部评论(0)
资料加载中...
已关注 , 取消