黑马程序员技术交流社区

标题: 线程的优先权 [打印本页]
作者: 胥文    时间: 2013-2-22 15:28
标题: 线程的优先权
假如在主函数中，我们创建3个线程。
我想问的是：主线程和我们创建的线程有没有优先权啊？还是电脑随机的
作者: 铿锵科技    时间: 2013-2-22 15:34
本帖最后由 铿锵科技 于 2013-2-22 15:54 编辑

默认创建的线程执行权是平等的
但是你可以使用setPriority改变线程执行优先权
例如：
  1. package com.itheima;
  2. public class MyThread extends Thread {
  3.         public static void main(String args[]) {
  4.                 MyThread myThread = new MyThread("myThread");
  5.                 MyThread thread1 = new MyThread("thread1");
  6.                 MyThread thread2 = new MyThread("thread2");
  7.                 MyThread thread3 = new MyThread("thread3");
  8.                 thread1.setPriority(MIN_PRIORITY);//执行权最小
  9.                 thread3.setPriority(MAX_PRIORITY);//执行权最大
  10.                 thread2.setPriority(NORM_PRIORITY);//执行权一般
  11.                 thread1.start();//执行权最小,最先启动
  12.                 thread2.start();//执行权一般,启动第2
  13.                 myThread.start();//默认执行权,启动第3
  14.                 thread3.start();//执行权最大,启动最后
  15.                
  16.         }
  17.         private String name;
  18.         MyThread(String name){
  19.                 this.name=name;
  20.         }
  21.         public void run() {
  22.                 try {
  23.                                 sleep(1000);
  24.                                 System.out.println(this.name+"线程运行");
  25.                         } catch (InterruptedException e) {
  26.                                 // TODO Auto-generated catch block
  27.                                 e.printStackTrace();
  28.                         }
  29.                         
  30.         }
  31. }
复制代码
输出的结果是最后启动的线程最先执行:

thread3线程运行
myThread线程运行
thread2线程运行
thread1线程运行
作者: 陈圳    时间: 2013-2-23 09:04
线程的优先级的范围是1-10;
默认所有线程的等级都是5;
可以通过操作Thread类的setPriority方法来改变线程的优先级,java把线程的优先级的三个范围封装成了常量
分别是:MIN_PRIORITY:最小:1
MAX_PRIORITY:10
NORW_PRIORITY:5
更改线程的优先级不如join()/yield()方法有效,他们直接让线程交出执行权,等别人执行完,或者是交出一次,这样更明显一些.
作者: 刘圣繁    时间: 2013-2-24 01:05
public class TestPriority// 线程的优先权 举例
{
    public static void main(String[] args)
    {
    Thread t1 = new Thread(new T1());
    Thread t2 = new Thread(new T2());
    t1.setPriority(Thread.NORM_PRIORITY + 3);//增加优先级
    t1.start();
    t2.start();
    }

}

class T1 implements Runnable
{
    public void run()
    {
    for (int i = 0; i < 1000; i++)
    {
        System.out.println("T1:" + i);
    }
    }
}

class T2 implements Runnable
{
    public void run()
    {
    for (int i = 0; i < 1000; i++)
    {
        System.out.println("---------T2:" + i);
    }
    }
}
优先级越高，就越可能被cpu调度执行该线程，但是对于java中的优先级来说不太可靠，系统自带一个线程的优先级，java程序中对线程所设置的优先级只是给系统一个提示一个建议，至于系统采纳不采纳就不一定了

就像java的垃圾回收机制一个道理  你只是通知到他了 但是他却不一定来的...

作者: 顾传文    时间: 2013-2-24 14:52
1.线程优先级范围在1-10之间。
System.out.println(Thread.MAX_PRIORITY); 打印结果：10
System.out.println(Thread.MIN_PRIORITY); 打印结果：1
System.out.println(Thread.NORM_PRIORITY);打印结果：5

2.当创建一个线程时，如果没有设置该线程的优先级，那么该线程的优先级就是父线程的优先级。如果一个线程没有父线程并且没有设置该线程的优先级，那么该线程默认的优先级为NORM_PRIORITY=5.
所以主线程的优先级是5.

3.线程优先级的注意事项。
看一段代码：
class MyThread extends Thread{
public void run(){
  System.out.println("优先级为"+this.getPriority()+"的线程运行");
}
}
class Test {
public static void main(String[] args) {
  for(int i=0;i<5;i++){
   MyThread thread = new MyThread();
   thread.setPriority(1);
   thread.start();
  }
  for(int i=0;i<5;i++){
   MyThread thread = new MyThread();
   thread.setPriority(5);
   thread.start();
  }
  for(int i=0;i<5;i++){
   MyThread thread = new MyThread();
   thread.setPriority(10);
   thread.start();
  }
}
}打印结果：
优先级为5的线程运行
优先级为5的线程运行
优先级为5的线程运行
优先级为10的线程运行
优先级为10的线程运行
优先级为10的线程运行
优先级为10的线程运行
优先级为5的线程运行
优先级为10的线程运行
优先级为5的线程运行
优先级为1的线程运行
优先级为1的线程运行
优先级为1的线程运行
优先级为1的线程运行
优先级为1的线程运行
从这个例子可以看出：优先级高的线程先运行（不能保证，只是概率大一些）。所以逻辑上不能靠优先级来控制。
作者: 张宁    时间: 2013-2-25 15:46
//定义一个ThreadImp类继承Thread类
class ThreadImp extends Thread{
      public void run(){
             for(int i = 0; i < 100 ; i ++){
                  System.out. println("This is the sub thread running -->" + i );
                   if(i ==50){
                     try{
                      Thread.sleep(3000);//让线程休眠3000毫秒，即 3 分钟。
                            }//Thread类的sleep方法一定要跑出异常
                         catch(Exception e){
                           e.printStackTrace();
                         }
                   }
                 }
          }
}
..............................................................................................
//主函数
class test{
    public static void main(String args[]){
            ThreadImp tr = new ThreadImp();//生成对象
                   tr.setPriority(10);//设置优先级 ，优先级从1到10 依次升高。
                  System.out.println(tr.getPriority());//得到优先级
                  tr.start();
                for (int j = 0; j < 100 ; j ++){
                 System.out.println("this is the main thread " + j);
                }
        }
}
给你一个例子吧。运行一下，你就能看到区别了。。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2