精华内容
下载资源
问答
  • Java程序基础 线程的优先级 线程的优先级 线程的优先级是指...线程线程的优先级 Thread类三个与线程优先级有关的静态变量其意义如下 MIN_PRIORITY线程能够具有的最小优先级1 MAX_PRIORITY线程能够具有的最大优先级1
  • 线程优先级

    2021-03-29 11:30:36
    线程优先级 1.MAX_PRIORITY:10 2.MIN_PRIORITY:1 3.NORM_PRIORITY:5------>默认优先级 如何获线程优先级 getPriority():获取当前线程优先级 setPriority(int p):设置当前线程优先级优先级线程要...

    线程的优先级
    1.MAX_PRIORITY:10
    2.MIN_PRIORITY:1
    3.NORM_PRIORITY:5------>默认优先级
    如何获线程的优先级
    getPriority():获取当前线程的优先级
    setPriority(int p):设置当前线程的优先级
    高优先级的线程要抢占低优先级线程的cpu执行权,一般情况,优先级越高,被执行的概率就越高,并不意味着高优先级的执行完之后执行低优先级的

    展开全文
  • 线程优先级 在应用程序中,如果要对线程进行调度,最直接的方式就是设置线程优先级优先级越高的线程获得CPU执行的机会越大,而优先级越低的线程获得CPU执行的机会越小。线程优先级用1~10之间的整数来表示,数字...

    线程的优先级

    在应用程序中,如果要对线程进行调度,最直接的方式就是设置线程的优先级。优先级越高的线程获得CPU执行的机会越大,而优先级越低的线程获得CPU执行的机会越小。线程的优先级用1~10之间的整数来表示,数字越大优先级越高。除了可以直接使用数字表示线程的优先级,还可以使用Thread类中提供的三个静态常量表示线程的优先级,如表所示。

    Thread静态常量功能描述
    static int MAX_PRIORITY表示线程的最高优先级,相当于值10
    static int MIN_PRIORITY表示线程的最低优先级,相当于值1
    static int NORM_PRIORIY表示线程的普通优先级,相当于值5

    程序在运行期间,处于就绪状态的每个线程都有自己的优先级,例如main线程具有普通优先级。然而线程优先级不是固定不变的,可以通过 Thread类的setPriority(int newPriority)方法对其进行设置,该方法中的参数newPriority接收的是1~10之间的整数或者Thread类的三个静态常量。接下来通过一个案例来演示不同优先级的两个线程在程序中的运行情况,如例所示。

    package 多线程;
    
    // 定义类MaxPriority实现Runnable接口
    class MaxPriority implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在输出:" + i);
            }
        }
    }
    // 定义类MinPriority实现Runnable接口
    class MinPriority implements Runnable {
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在输出:" + i);
            }
        }
    }
    class Example07 {
        public static void main(String[] args) {
            // 创建两个线程
            Thread minPriority = new Thread(new MinPriority(), "优先级较低的线程");
            Thread maxPriority = new Thread(new MaxPriority(), "优先级较高的线程");
            minPriority.setPriority(Thread.MIN_PRIORITY); // 设置线程的优先级为1
            maxPriority.setPriority(10); // 设置线程的优先级为10
            // 开启两个线程
            maxPriority.start();
            minPriority.start();
        }
    }
    
    

    在这里插入图片描述
    需要注意的是,虽然Java中提供了10个线程优先级,但是这些优先级需要操作系统的支持,不同的操作系统对优先级的支持是不一样的,不能很好的和Java中线程优先级一一对应,因此,在设计多线程应用程序时,其功能的实现一定不能依赖于线程的优先级,而只能把线程优先级作为一种提高程序效率的手段。

    线程让步

    线程让步可以通过yield()方法来实现,该方法和sleep()方法有点相似,都可以让当前正在运行的线程暂停,区别在于yield()方法不会阻塞该线程,它只是将线程转换成就绪状态,让系统的调度器重新调度一次。(下一次的调度如果是相同优先级的线程,随机调度)当某个线程调用yield()方法之后,只有与当前线程优先级相同或者更高的线程才能获得执行的机会。接下来通过一个案例来演示一下yield()方法的使用。

    // 定义YieldThread类继承Thread类
    class YieldThread extends Thread {
         // 定义一个有参的构造方法
    	public YieldThread(String name) { 
    		super(name); // 调用父类的构造方法
    	}
    	public void run() {
    		for (int i = 0; i < 5; i++) {
    			System.out.println(Thread.currentThread().getName() + "---" + i);
    			if (i == 3) {
    				System.out.print("线程让步:");
    				Thread.yield(); // 线程运行到此,作出让步
    			}
    		}
    	}
    }
    public class Example09 {
    	public static void main(String[] args) {
             // 创建两个线程
    		Thread t1 = new YieldThread("线程A");
    		Thread t2 = new YieldThread("线程B");
             // 开启两个线程
    		t1.start();
    		t2.start();
    	}
    }
    
    

    在这里插入图片描述

    线程插队

    现实生活中经常能碰到“插队”的情况,同样,在 Thread类中也提供了一个 join()方法来实现这个“功能”。当在某个线程中调用其他线程的join()方法时,调用的线程将被阻塞,直到被join()方法加人的线程执行完成后它才会继续运行。

    public class Example10{
    	public static void main(String[] args) throws Exception {
    		// 创建线程
    		Thread t = new Thread(new EmergencyThread(),"线程一");
    		t.start(); // 开启线程
    		for (int i = 1; i < 6; i++) {
    			System.out.println(Thread.currentThread().getName()+"输入:"+i);
    			if (i == 2) {
    				t.join(); // 调用join()方法
    			}
    			Thread.sleep(500); // 线程休眠500毫秒
    		}
    	}
    }
    class EmergencyThread implements Runnable {
    	public void run() {
    		for (int i = 1; i < 6; i++) {
    			System.out.println(Thread.currentThread().getName()+"输入:"+i);
    			try {
    				Thread.sleep(500); // 线程休眠500毫秒
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    

    在这里插入图片描述

    展开全文
  • 线程优先级小知识子线程会使用父线程的优先级线程内使用线程线程优先级越高,是否优先执行? 前言 上一篇文章,我们了解线程安全的那些事,以及如何去解决线程安全的问题,本文就来聊一聊线程的优先级。 1.线程...
  • 线程的优先级 在操作系统中,线程可以划分优先级,优先级高的线程得到CPU执行权的机会多,也就是说优先级高的...1.10.1 线程优先级的继承性 什么是优先级的继承性?就是说如果优先级为5的线程A启动了线程B,那么...

    线程的优先级

    在操作系统中,线程可以划分优先级,优先级高的线程得到CPU执行权的机会多,也就是说优先级高的线程可能会先执行。

    setPriority()方法可以设置线程的优先级,一般线程的优先级数值是1~10,如果超过这个范围会抛出异常IllegalArguementException。

    1.10.1 线程优先级的继承性

    什么是优先级的继承性?就是说如果优先级为5的线程A启动了线程B,那么这时候线程B的优先级也就是5,比如我们将主线程设置的优先级设置为1,那么主线程启动了A线程,这时A线程的优先级也应该是1。

    public class MyThread1 extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread1 run priority = " + this.getPriority());
            MyThread2 thread2 = new MyThread2();
            thread2.start();
        }
    }
    
    
    public class MyThread2 extends Thread {
        @Override
        public void run() {
            System.out.println("Mythread2 run priority = " + this.getPriority());
        }
    }
    
    package cn.zxyy.multiThread.Thread.priority;
    
    /*
    * 线程的优先级具有继承性,默认值是5
    * 然后如果是A线程启动了B线程,那么B线程的优先级会与A线程一样
    * */
    public class Run {
        public static void main(String[] args) {
            //这里main线程的值是5
            System.out.println("main thread begin priority = " + Thread.currentThread().getPriority());
    
            //先注释这一行 Thread.currentThread().setPriority(6);
            //运行结果是5,main线程的优先级没有改变,它启动了thread1线程,所以根据继承性,thread1的优先级也是5
            System.out.println("main thread end priority = " +Thread.currentThread().getPriority());
            MyThread1 thread1 = new MyThread1();
            //然后thread1启动了thread2 ,所以thread2的优先级也是5
            thread1.start();
        }
    }
    

     

    注释设置优先级代码的运行结果
    取消注释设置优先级代码的运行结果

     

       从上面的运行结果可以看到,如果不设置优先级,默认的数值是5,由于主线程启动了myThread1线程,这是myThread1的优先级就是5,因为myThread1启动了myThread2,所以myThread2的优先级也是5。

    然后再取消注释,主线程优先级默认为5,我们将其设置为6,后面myThread1和myThread2的优先级都变成了6,这就是线程优先级的继承性。

    1.10.2 优先级具有规则性

    优先级具有规则性:就是优先级高的线程一般都是先执行完。

    package cn.zxyy.multiThread.Thread.priorityRule;
    
    import java.util.Random;
    
    public class MyThread1 extends Thread {
        @Override
        public void run() {
            long beginTime = System.currentTimeMillis();
            long addResult = 0L;
            for (int j = 0; j < 10; j++) {
                for (int i = 0; i < 50000; i++) {
                    Random random = new Random();
                    random.nextInt();
                    addResult = addResult + i;
                }
            }
            long endTime = System.currentTimeMillis();
            System.out.println(" ###### thread1 use time  = " + (endTime - beginTime));
        }
    }
    package cn.zxyy.multiThread.Thread.priorityRule;
    
    import java.util.Random;
    
    public class MyThread2 extends Thread {
        @Override
        public void run() {
            long beginTime = System.currentTimeMillis();
            long addResult = 0L;
            for (int j = 0; j < 10; j++) {
                for (int i = 0; i < 50000; i++) {
                    Random random = new Random();
                    random.nextInt();
                    addResult = addResult + i;
                }
            }
            long endTime = System.currentTimeMillis();
            System.out.println(" $$$$$$ thread2 use time  = " + (endTime - beginTime));
        }
    }
    package cn.zxyy.multiThread.Thread.priorityRule;
    
    public class Run {
        public static void main(String[] args) {
            for (int i = 0; i < 5; i++) {
                MyThread1 myThread1 = new MyThread1();
                myThread1.setPriority(1);
                myThread1.start();
                MyThread2 myThread2 = new MyThread2();
                myThread2.setPriority(10);
                myThread2.start();
            }
        }
    }

      

    从运行结果可以看到,第一次将thread1优先级设置为3,thread2优先级设置为4。第二次将thread1优先级设置为1,thread2优先级设置为10。可以看到优先级高的线程一般都是先执行完。

    注:值越大,优先级越高,10是最高的优先级,1是最低的优先级。

    1.10.3 优先级具有随机性

    上面我们说到了优先级的规则性:优先级高的线程一般都是先执行完。之所以不能说成优先级高的线程一定先执行完,是因为优先级也具有随机性,不是每次都是优先级高的线程先执行完。

    1.10.4 看谁运行得快

    一般情况下优先级高的线程运行时间快。

    package cn.zxyy.multiThread.Thread.countPriority;
    
    public class MyThread1 extends Thread {
        private long count = 0 ;
    
        public long getCount() {
            return count;
        }
    
        @Override
        public void run() {
            while(true){
                count++;
            }
        }
    }
    
    
    
    package cn.zxyy.multiThread.Thread.countPriority;
    
    public class MyThread2 extends Thread {
        private long count = 0 ;
    
        public long getCount() {
            return count;
        }
    
        @Override
        public void run() {
            while(true){
                count++;
            }
        }
    }
    package cn.zxyy.multiThread.Thread.countPriority;
    
    
    public class Run {
        public static void main(String[] args) {
            try{
                MyThread1  a = new MyThread1();
                a.setPriority(2);
                a.start();
                MyThread2 b = new MyThread2();
                b.setPriority(8);
                b.start();
                Thread.sleep(20000);
                a.stop();
                b.stop();
                System.out.println("a = " + a.getCount());
                System.out.println("b = " + b.getCount());
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
    

     1.11 守护线程

    Java中有两种线程,一种是用户线程,另外一种就是守护线程(Daemon);

    守护线程就是一种特殊的线程,顾名思义守护,陪伴某些线程。

    当非守护线程结束了,那么守护线程也就自动销毁了。最典型的守护线程就是垃圾回收线程,当进程中没有非守护线程了,那么垃圾回收线程也就自动销毁了。

    当有多个非守护线程的时候,只要有其中一个非守护线程没有结束,那么守护线程就还要存在,但是当所有非守护线程都执行完毕,这时候守护线程也就可以一起结束工作了。

    package cn.zxyy.multiThread.Thread.daemonThread;
    
    public class MyThread extends Thread {
        private int i = 0 ;
    
        @Override
        public void run() {
            try{
                while(true){
                    i++;
                    System.out.println("i = " + i);
                    Thread.sleep(1000);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
    package cn.zxyy.multiThread.Thread.daemonThread;
    
    public class Run {
        public static void main(String[] args) {
            try{
                MyThread myThread = new MyThread();
                myThread.setDaemon(true);
                myThread.start();
                Thread.sleep(5000);
                System.out.println("我离开myThread对象也不再打印了,也就是停止了");
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

     

    总结:

    1.线程的优先级具有继承性:线程被哪个线程启动,就继承哪个线程的优先级。

    2.线程的优先级具有规则性:一般情况下,优先级高的线程会先执行完。

    3.线程的优先级具有随机性:并不是每次都是优先级高的线程先执行完。

    4.一般情况下,优先级高的线程执行的速度会比较快。

    5.守护线程一定是等到所有的非守护线程全部执行完毕,才会自动销毁,垃圾回收线程就是一个守护线程。

    展开全文
  • 线程优先级作用

    2021-05-18 08:39:46
    线程优先级: 1.MAX_PRIORITY :10 MIN_PRIORITY :1 NORM_PRIORITY :5 -->默认优先级 2.如何获取和设置当前线程优先级: getPriority():获取线程优先级 setPriority(int p):设置线程优先级 说明:高...

    线程的优先级:
    1.MAX_PRIORITY :10
      MIN_PRIORITY :1
      NORM_PRIORITY :5 -->默认优先级
    2.如何获取和设置当前线程的优先级:
      getPriority():获取线程的优先级
      setPriority(int p):设置线程的优先级
    说明:高优先级的线程要抢占低优先级线程的cpu的执行权。但是只是从概率上讲,高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后,低优先级的线程才执行。

    public class ThreadMethodTest {
        public static void main(String[] args) {
            Thread.currentThread().setName("主线程");
            Thread.currentThread().setPriority(MIN_PRIORITY);
            HelloThread h1 = new HelloThread();
            h1.setName("线程一");
            h1.setPriority(MAX_PRIORITY);
            h1.start();
            for (int i = 0; i < 1000; i++) {
                if(i % 2 != 0){
                    System.out.println(Thread.currentThread().getName() +":"+Thread.currentThread().getPriority()  + ":" + i);
                }
    
    
            }
    
        }
    }
    
    class HelloThread extends  Thread{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if(i % 2 == 0){
                    System.out.println(getName() +"+" + getPriority() + ":" + i);
                }
    
            }
        }
    }

    运行结果:

    从而印证了线程优先级的高低是概率问题,并不是一定会执行完,低优先级的线程才会执行。就如转幸运大转盘,就算三分之二都是中奖,仍然有可能好几次都不中奖。

    Java小白,刚开始学习,不喜勿喷,欢迎讨论。

    展开全文
  • 设置线程优先级

    2018-04-09 10:32:15
    设置线程优先级,设置参数 afebegeinthreand 设置参数 简单dedemo vc2008
  • 优先级线程组成先进先出队列(先到先服务),使用时间片策略。 对高优先级,使用优先调度的抢占式策略。 线程优先级等级 Thread.MAX_PRIORITY:10 Thread.MIN _PRIORITY:1 Thread.NORM_PRIORITY:5 ...
  • Java线程优先级

    千次阅读 2018-05-19 15:19:22
    先来看下对于设置线程优先级的源码: 其中:MAX_PRIORITY和MIN_PRIORITY分别是最高级10和最低级1,当然还有默认级别是5; 接着看下线程优先级的一些特性: 线程优先级的继承特性:也就是如果线程A启动线程B,那么...
  • 在操作系统中,线程可以划分优先级优先级较高的线程得到的CPU资源越多,也就是CPU优先执行优先级较高的线程对象中的任务。 在Java中,线程优先级分为1~10这10个等级,如果小于1或大于10,则JDK抛出异常throw ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 277,128
精华内容 110,851
关键字:

线程有优先级吗