精华内容
参与话题
问答
  • * <p>Title: 提高线程优先级 * <p>Description: 通过修改线程的优先级,是线程获得优先处理。 * <p>Copyright: Copyright (c) 2003 * <p>Filename: upPRIThread.java * @author * @version 1.0
  • 优先级由1到10之间数字表示。在大多数情况下,线程根据其优先级(称为抢占式调度)调度线程。但是它不能保证,因为它依赖于JVM规范,它选择哪个调度。 3个常量在Thread类中defiend: public ...
    每个线程都有优先级。优先级由1到10之间的数字表示。在大多数情况下,线程根据其优先级(称为抢占式调度)调度线程。但是它不能保证,因为它依赖于JVM规范,它选择哪个调度。

    3个常量在Thread类中defiend:

    1. public static int MIN_PRIORITY
    2. public static int NORM_PRIORITY
    3. public static int MAX_PRIORITY
    线程的默认优先级为5(NORM_PRIORITY)。MIN_PRIORITY的值为1,MAX_PRIORITY的值为10。

    线程优先级示例:

    1. class TestMultiPriority1 extends Thread{
    2.  public void  run(){   
    3.    System.out.println(“运行时线程的名称:” + Thread.currentThread()。getName());  
    4.    System.out.println(“运行时线程的优先级:” + Thread.currentThread().getPriority());  
    5.   
    6.   }  
    7.  public static void  main(String args []){    
    8.   TestMultiPriority1 m1 = new  TestMultiPriority1();  
    9.   TestMultiPriority1 m2 = new  TestMultiPriority1();  
    10.   m1.setPriority(Thread.MIN_PRIORITY);  
    11.   m2.setPriority(Thread.MAX_PRIORITY);  
    12.   m1.start();  
    13.   m2.start();  
    14.    
    15.  }  
    16. }     
    现在测试
    输出: 运行线程名称为:Thread-0
           运行线程的优先级是:10
           运行的线程名称是:Thread-1
           运行线程的优先级是:1
           
     
    展开全文
  • java线程池多线程优先级 Java线程优先级 (Java Thread Priorities) Priority of a thread describes how early it gets execution and selected by the thread scheduler. In Java, when we create a thread, ...

    java线程池多线程优先级

    Priority of a thread describes how early it gets execution and selected by the thread scheduler. In Java, when we create a thread, always a priority is assigned to it. In a Multithreading environment, the processor assigns a priority to a thread scheduler. The priority is given by the JVM or by the programmer itself explicitly. The range of the priority is between 1 to 10 and there are three constant variables which are static and used to fetch priority of a Thread. They are as following:

    线程的优先级描述了线程调度程序提早执行和选择线程的时间。 在Java中,当我们创建线程时,总是为其分配优先级。 在多线程环境中,处理器将优先级分配给线程调度程序。 优先级由JVM或程序员本身明确指定。 优先级的范围在1到10之间,并且有三个常量,它们是静态的,用于获取线程的优先级。 它们如下:

    1. public static int MIN_PRIORITY (1. public static int MIN_PRIORITY)

    It holds the minimum priority that can be given to a thread. The value for this is 1.

    它拥有可以赋予线程的最低优先级。 该值为1。

    2. public static int NORM_PRIORITY (2. public static int NORM_PRIORITY)

    It is the default priority that is given to a thread if it is not defined. The value for this is 0.

    如果未定义,则它是赋予线程的默认优先级。 该值为0。

    3. public static int MAX_PRIORITY (3. public static int MAX_PRIORITY)

    It is the maximum priority that can be given to a thread. The value for this is 10.

    它是可以赋予​​线程的最大优先级。 该值为10。

    线程优先级中的Get和Set方法 (Get and Set methods in Thread priority)

    1. public final intgetPriority() (1. public final intgetPriority())

    In Java, getPriority() method is in java.lang.Thread package. it is used to get the priority of a thread.

    在Java中,getPriority()方法位于java.lang.Thread包中。 它用于获取线程的优先级。

    2. public final void setPriority(intnewPriority) (2. public final void setPriority(intnewPriority))

    In Java setPriority(intnewPriority) method is in java.lang.Thread package. It is used to set the priority of a thread. The setPriority() method throws IllegalArgumentException if the value of new priority is above minimum and maximum limit.

    在Java中,setPriority(intnewPriority)方法在java.lang.Thread包中。 它用于设置线程的优先级。 如果新优先级的值高于最小和最大限制,则setPriority()方法将引发IllegalArgumentException。

    示例:获取线程优先级 (Example: Fetch Thread Priority)

    If we don’t set thread priority of a thread then by default it is set by the JVM. In this example, we are getting thread’s default priority by using the getPriority() method.

    如果我们不设置线程的线程优先级,则默认情况下由JVM设置。 在此示例中,我们通过使用getPriority()方法获取线程的默认优先级。

    class MyThread extends Thread 
    { 
    	public void run() 
    	{ 
    		System.out.println("Thread Running..."); 
    	} 
    
    	public static void main(String[]args) 
    	{ 
    		MyThread p1 = new MyThread(); 
    		MyThread p2 = new MyThread(); 
    		MyThread p3 = new MyThread(); 
    		p1.start();
    		System.out.println("P1 thread priority : " + p1.getPriority()); 
    		System.out.println("P2 thread priority : " + p2.getPriority());  
    		System.out.println("P3 thread priority : " + p3.getPriority()); 
    		
    	} 
    }

    P1 thread priority : 5 Thread Running... P2 thread priority : 5 P3 thread priority : 5

    P1线程优先级:5线程运行中... P2线程优先级:5 P3线程优先级:5

    示例:线程常量 (Example: Thread Constants)

    We can fetch priority of a thread by using some predefined constants provided by the Thread class. these constants returns the max, min and normal priority of a thread.

    我们可以使用Thread类提供的一些预定义常量来获取线程的优先级。 这些常量返回线程的最大,最小和普通优先级。

    class MyThread extends Thread 
    { 
    	public void run() 
    	{ 
    		System.out.println("Thread Running..."); 
    	} 
    
    	public static void main(String[]args) 
    	{ 
    		MyThread p1 = new MyThread(); 
    		p1.start();
    		System.out.println("max thread priority : " + p1.MAX_PRIORITY); 
    		System.out.println("min thread priority : " + p1.MIN_PRIORITY);  
    		System.out.println("normal thread priority : " + p1.NORM_PRIORITY); 
    		
    	} 
    }

    Thread Running... max thread priority : 10 min thread priority : 1 normal thread priority : 5

    线程运行中...最大线程优先级:10最小线程优先级:1正常线程优先级:5

    示例:设置优先级 (Example : Set Priority)

    To set priority of a thread, setPriority() method of thread class is used. It takes an integer argument that must be between 1 and 10. see the below example.

    要设置线程的优先级,请使用线程类的setPriority()方法。 它采用必须在1到10之间的整数参数。请参见以下示例。

    class MyThread extends Thread 
    { 
    	public void run() 
    	{ 
    		System.out.println("Thread Running..."); 
    	} 
    
    	public static void main(String[]args) 
    	{ 
    		MyThread p1 = new MyThread();
    		// Starting thread
    		p1.start();
    		// Setting priority
    		p1.setPriority(2);
    		// Getting priority
    		int p = p1.getPriority();
    		
    		System.out.println("thread priority : " + p);  
    		
    	} 
    }

    thread priority : 2 Thread Running...

    线程优先级:2线程正在运行...

    例: (Example: )

    In this example, we are setting priority of two thread and running them to see the effect of thread priority. Does setting higher priority thread get CPU first. See the below example.

    在此示例中,我们设置两个线程的优先级并运行它们以查看线程优先级的效果。 设置更高优先级的线程是否首先获取CPU。 请参见以下示例。

    class MyThread extends Thread 
    { 
    	public void run() 
    	{ 
    		System.out.println("Thread Running... "+Thread.currentThread().getName()); 
    	} 
    
    	public static void main(String[]args) 
    	{ 
    		MyThread p1 = new MyThread();
    		MyThread p2 = new MyThread();
    		// Starting thread
    		p1.start();
    		p2.start();
    		// Setting priority
    		p1.setPriority(2);
    		// Getting -priority
    		p2.setPriority(1);
    		int p = p1.getPriority();
    		int p22 = p2.getPriority();
    		
    		System.out.println("first thread priority : " + p);  
    		System.out.println("second thread priority : " + p22);
    		
    	} 
    }

    Thread Running... Thread-0 first thread priority : 5 second thread priority : 1 Thread Running... Thread-1

    线程运行中...线程-0第一个线程优先级:5第二个线程优先级:1线程运行中...线程-1

    Note: Thread priorities cannot guarantee that a higher priority thread will always be executed first than the lower priority thread. The selection of the threads for execution depends upon the thread scheduler which is platform dependent.

    注意:线程优先级不能保证高优先级的线程总是比低优先级的线程优先执行。 执行线程的选择取决于平台相关的线程调度程序。

    翻译自: https://www.studytonight.com/java/thread-priorities-in-java.php

    java线程池多线程优先级

    展开全文
  • 我在linux中创建了两个线程Task0和Task1,并且修改了线程的优先级,工作方式为SCHED_FIFO,但是不知道为什么执行起来并没有显示抢占的现象,反而感觉像是时间片轮的方式执行的,两个线程交替执行。并且两个线程执行...
  • 在实现java编程思想小例子时候发现运行结果不一样,书上结果是先执行完优先级最高才执行优先级,但是我却没有先把优先级最高的线程执行完 代码如下: package concurrency; import java.util....
  • 这是java线程的优先级: java.lang.Thread public static final int MAX_PRIORITY 10 public static final int MIN_PRIORITY 1 public static final int NORM_PRIORITY 5 ...
  • Java线程优先级

    2017-04-09 16:32:38
    操作系统会分出一个个时间片,线程会被分配到若干个时间片,当线程的时间片用完了就会发生线程调度,并且等待着下次调度,线程被分配到的时间片多少也就决定了线程使用处理器资源的多少,而线程优先级就是决定线程...


    操作系统基本采用时分的调度运行线程,操作系统会分出一个个时间片,线程会被分配到若干个时间片,当线程的时间片用完了就会发生线程调度,并且等待着下次调度,线程被分配到的时间片多少也就决定了线程使用处理器资源的多少,而线程优先级就是决定线程能够分配多少处理器资源的线程属性。

    在Java多线程中,通过一个整形变量priority来控制优先级,优先级的范围从1-10.默认是5,优先级越高越好。

    public class Priority {
    	public static void main(String[] args) {
    		Thread t1 = new Mythread();
    		t1.setName("线程1");
    		t1.setPriority(1); //设置优先级
    		Thread t2 = new Mythread();
    		t2.setName("线程2");
    		t2.setPriority(10); //设置优先级
    		t1.start();
    		t2.start();
    	} 
    }
    class Mythread extends Thread{
    	@Override
    	public void run() {
    		for(int i=0;i<10;i++){
    			System.out.println(getName()+"执行"+i+"次");
    		}
    	}
    }
    执行结果:

    线程2执行0次
    线程2执行1次
    线程2执行2次
    线程2执行3次
    线程2执行4次
    线程2执行5次
    线程2执行6次
    线程2执行7次
    线程2执行8次
    线程2执行9次
    线程1执行0次
    线程1执行1次
    线程1执行2次
    线程1执行3次
    线程1执行4次
    线程1执行5次
    线程1执行6次
    线程1执行7次
    线程1执行8次
    线程1执行9次
    
    我们可以看到系统会优先执行线程1。但是也并不是每次都会优先执行线程1的,特别是两个线程优先级区别不是很大的时候,线程优先级基本上作用不大。线程优先级不能作为程序正确性的依赖,因为操作系统可以完全不用理会java线程对于优先级的决定。





    展开全文
  • 线程优先级

    2019-01-22 09:39:41
    线程的优先级就是告诉程序每个线程的重要程度。如果有大量的线程被堵塞,都在等待运行,程序会尽可能地运行优先级高的那个线程。但是并不代表优先级低的线程不会运行,只是说优先级低的线程被允许执行的概率会比高...

    什么是线程优先级?

    线程的优先级就是告诉程序每个线程的重要程度。如果有大量的线程被堵塞,都在等待运行,程序会尽可能地运行优先级高的那个线程。但是并不代表优先级低的线程不会运行,只是说优先级低的线程被允许执行的概率会比高优先级线程允许执行的概率低。

    查看Thread源码可以看到,线程优先级最大是10, 最小是1 ,默认是5,一般情况下推荐使用下面三个常量,不要自行设置数值。

        /**
         * The minimum priority that a thread can have.
         */
        public final static int MIN_PRIORITY = 1;
    
       /**
         * The default priority that is assigned to a thread.
         */
        public final static int NORM_PRIORITY = 5;
    
        /**
         * The maximum priority that a thread can have.
         */
        public final static int MAX_PRIORITY = 10;

     

    下面看两个简单的例子

    1.未设置优先级是运行两个线程

    public class PriorityDemo {
    
        public static void main(String[] args)  {
            Thread thread1 = new Thread(()->{
                while (true){
                    try {
                        Thread.sleep(300l);
                        System.out.println(Thread.currentThread().getName());
                    }catch (InterruptedException e){
                        e.printStackTrace();
    
                    }
                }
    
            },"线程1");
    
    
            Thread thread2 = new Thread(()->{
                while (true) {
                    try {
                        Thread.sleep(300l);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"线程2");
    
    
            thread1.start();
            thread2.start();
    
        }
    }
    

    运行结果:

    线程2
    线程1
    线程2
    线程1
    线程2
    线程1
    线程2
    线程1

    2.设置最大最小等级的两个线程

    public class PriorityDemo {
    
        public static void main(String[] args)  {
            Thread thread1 = new Thread(()->{
                while (true){
                    try {
                        Thread.sleep(300l);
                        System.out.println(Thread.currentThread().getName());
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
    
            },"线程1");
    
    
            Thread thread2 = new Thread(()->{
                while (true) {
                    try {
                        Thread.sleep(300l);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"线程2");
    
            thread1.setPriority(Thread.MIN_PRIORITY);
            thread2.setPriority(Thread.MAX_PRIORITY);
            thread1.start();
            thread2.start();
    
        }
    }
    

    运行结果:

    线程2
    线程2
    线程1
    线程2
    线程1

      通过查看上面两个简单的例子,发现基本符合上面的理论说明。

      不同的平台,对线程优先级的支持不同。编程的时候,不要过度的依赖线程的优先级。

    展开全文
  • Java 多线程系列第 6 篇。
  • 线程优先级的设定

    千次阅读 2018-08-28 13:49:28
    线程的优先级: 1-10,10为最高级别,1为最低级别,5为默认级别 Thread.MIN_PRIORITY--最小优先级 Thread.MAX_PRIORITY--最高优先级 Thread.NORM_PRIORITY--默认优先级 设置优先级: public class JoinThread2 { ...
  • 中断优先级和中断线程优先级

    万次阅读 2010-02-09 17:10:00
    中断是一种当今很重要硬件与cpu通信方式,...这种机制结果就是使一切变得有序化,出现多竞争一情况时,最常用方法就是排队,而排队有很多策略,比如先来先服务,优先级队列,加权优先级队列,多级队列等等。
  • java的线程优先级

    2014-07-15 22:40:24
    今天看了下里面一段关于java线程优先级的代码.奇怪于它运行结果,二话不说,直接运行代码测试. 代码: package bookcode.twentyfirst; import java.util.concurrent.ExecutorService; import java.util....
  • 示例代码: public static void main(String[] args) throws ... //设置线程优先级 threadGroup.setMaxPriority(6); Thread thread = new Thread(threadGroup, "线程一"); System.out.println(
  • 主要介绍了C++线程优先级SetThreadPriority使用实例,较为详细讲述了C++线程及其优先级用法,需要朋友可以参考下

空空如也

1 2 3 4 5 ... 20
收藏数 10,760
精华内容 4,304
关键字:

线程优先级