精华内容
下载资源
问答
  • java线程优先级越高越先执行吗

    千次阅读 2016-04-01 14:13:58
    不是优先级越高,线程就先执行 优先级反映的是线程占用资源的多少,优先级越高,占用的资源越多,性能越好
    不是优先级越高,线程就先执行  优先级反映的是线程占用资源的多少,优先级越高,占用的资源越多,性能越好
    
    展开全文
  • 各位志同道合的朋友们大家,我是一个一直在一线互联网踩坑十余年的编码爱好者,现在将我们的各种经验以及架构实战分享出来,如果大家喜欢,就关注我,一起将技术学深学透,我会每一篇分享结束都会预告下一专题线程...

    各位志同道合的朋友们大家好,我是一个一直在一线互联网踩坑十余年的编码爱好者,现在将我们的各种经验以及架构实战分享出来,如果大家喜欢,就关注我,一起将技术学深学透,我会每一篇分享结束都会预告下一专题

    线程介绍

    线程(Thread)是程序运行的执行单元,依托于进程存在。一个进程中可以包含多个线程,多线程可以共享一块内存空间和一组系统资源,因此线程之间的切换更加节省资源、更加轻量化,因而也被称为轻量级的进程。

    什么是进程

    进程(Processes)是程序的一次动态执行,是系统进行资源分配和调度的基本单位,是操作系统运行的基础,通常每一个进程都拥有自己独立的内存空间和系统资源。简单来说,进程可以被当做是一个正在运行的程序。

    为什么需要线程

    程序的运行必须依靠进程,进程的实际执行单元就是线程。

    为什么需要多线程

    多线程可以提高程序的执行性能。例如,有个 90 平方的房子,一个人打扫需要花费 30 分钟,三个人打扫就只需要 10 分钟,这三个人就是程序中的“多线程”。

    线程使用

    线程的创建,分为以下三种方式:

    • 继承 Thread 类,重写 run 方法
    • 实现 Runnable 接口,实现 run 方法
    • 实现 Callable 接口,实现 call 方法

    下面分别来看看线程创建和使用的具体代码。

    1)继承 Thread 类

    请参考以下代码:

    class ThreadTest {    public static void main(String[] args) throws Exception {        MyThread thread = new MyThread();        thread.start();    }}class MyThread extends Thread {    @Override    public void run() {        System.out.println("Thread");    }}
    98ca994099428ed21fe35be9670d527e.gif

    以上程序执行结果如下:

    Thread

    2)实现 Runnable 接口

    请参考以下代码:

    class ThreadTest {    public static void main(String[] args) {        MyRunnable runnable = new MyRunnable();        new Thread(runnable).start();    }}class MyRunnable implements Runnable {    @Override    public void run() {        System.out.println("Runnable");    }}
    98ca994099428ed21fe35be9670d527e.gif

    以上程序执行结果如下:

    Runnable

    3)实现 Callable 接口

    请参考以下代码:

    class ThreadTest {    public static void main(String[] args) throws Exception {        MyCallable callable = new MyCallable();        // 定义返回结果        FutureTask result = new FutureTask(callable);        // 执行程序        new Thread(result).start();        // 输出返回结果        System.out.println(result.get());    }}class MyCallable implements Callable {    @Override    public String call() {        System.out.println("Callable");        return "Success";    }}
    98ca994099428ed21fe35be9670d527e.gif

    以上程序执行结果如下:

    Callable

    Success

    可以看出,Callable 的调用是可以有返回值的,它弥补了之前调用线程没有返回值的情况,它是随着 JDK 1.5 一起发布的。

    4)JDK 8 创建线程

    JDK 8 之后可以使用 Lambda 表达式很方便地创建线程,请参考以下代码:

    new Thread(() -> System.out.println("Lambda Of Thread.")).start();

    线程高级用法

    线程等待

    使用 wait() 方法实现线程等待,代码如下:

    System.out.println(LocalDateTime.now());Object lock = new Object();Thread thread = new Thread(() -> {    synchronized (lock){        try {            // 1 秒钟之后自动唤醒            lock.wait(1000);            System.out.println(LocalDateTime.now());        } catch (InterruptedException e) {            e.printStackTrace();        }    }});thread.start();
    98ca994099428ed21fe35be9670d527e.gif

    以上程序执行结果如下:

    2019-06-22T20:53:08.776

    2019-06-22T20:53:09.788

    注意:当使用 wait() 方法时,必须先持有当前对象的锁,否则会抛出异常 java.lang.IllegalMonitorStateException。

    线程唤醒

    使用 notify()/notifyAll() 方法唤醒线程。

    • notify() 方法随机唤醒对象的等待池中的一个线程;
    • notifyAll() 唤醒对象的等待池中的所有线程。

    使用如下:

    Object lock = new Object();lock.wait();lock.notify();// lock.notifyAll();线程休眠// 休眠 1 秒Thread.sleep(1000);等待线程执行完成Thread joinThread = new Thread(() -> {    try {        System.out.println("执行前");        Thread.sleep(1000);        System.out.println("执行后");    } catch (InterruptedException e) {        e.printStackTrace();    }});joinThread.start();joinThread.join();System.out.println("主程序");
    98ca994099428ed21fe35be9670d527e.gif

    以上程序执行结果:

    执行前

    执行后

    主程序

    yield 交出 CPU 执行权

    new Thread(){    @Override    public void run() {        for (int i = 1; i 
    98ca994099428ed21fe35be9670d527e.gif

    注意:yield 方法是让同优先级的线程有执行的机会,但不能保证自己会从正在运行的状态迅速转换到可运行的状态。

    线程中断

    使用 System.exit(0) 可以让整个程序退出;要中断单个线程,可配合 interrupt() 对线程进行“中断”。使用代码如下:

    Thread interruptThread = new Thread() {    @Override    public void run() {        for (int i = 0; i 
    98ca994099428ed21fe35be9670d527e.gif

    线程优先级

    在 Java 语言中,每一个线程有一个优先级,默认情况下,一个线程继承它父类的优先级。可以使用 setPriority 方法设置(1-10)优先级,默认的优先级是 5,数字越大表示优先级越高,优先级越高的线程可能优先被执行的概率就越大。设置优先级的代码如下:

    Thread thread = new Thread(() -> System.out.println("Java"));thread.setPriority(10);thread.start();
    98ca994099428ed21fe35be9670d527e.gif

    死锁

    死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。比如,当线程 A 持有独占锁 a,并尝试去获取独占锁 b 的同时,线程 B 持有独占锁 b,并尝试获取独占锁 a 的情况下,就会发生 A B 两个线程由于互相持有对方需要的锁,而发生的阻塞现象,我们称为死锁。死锁示意图如下所示:

    a347204505c6e7b2e156bda5e7862ba7.png
    98ca994099428ed21fe35be9670d527e.gif

    ​死锁代码:

    Object obj1 = new Object();Object obj2 = new Object();// 线程1拥有对象1,想要等待获取对象2new Thread() {    @Override    public void run() {        synchronized (obj1) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized (obj2) {                System.out.println(Thread.currentThread().getName());            }        }    }}.start();// 线程2拥有对象2,想要等待获取对象1new Thread() {    @Override    public void run() {        synchronized (obj2) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized (obj1) {                System.out.println(Thread.currentThread().getName());            }        }    }}.start();
    98ca994099428ed21fe35be9670d527e.gif

    相关面试题

    1.线程和进程有什么区别和联系?

    答:从本质上来说,线程是进程的实际执行单元,一个程序至少有一个进程,一个进程至少有一个线程,它们的区别主要体现在以下几个方面:

    • 进程间是独立的,不能共享内存空间和上下文,而线程可以;
    • 进程是程序的一次执行,线程是进程中执行的一段程序片段;
    • 线程占用的资源比进程少。

    2.如何保证一个线程执行完再执行第二个线程?

    答:使用 join() 方法,等待上一个线程的执行完之后,再执行当前线程。示例代码:

    Thread joinThread = new Thread(() -> {    try {        System.out.println("执行前");        Thread.sleep(1000);        System.out.println("执行后");    } catch (InterruptedException e) {        e.printStackTrace();    }});joinThread.start();joinThread.join();System.out.println("主程序");
    98ca994099428ed21fe35be9670d527e.gif

    3.线程有哪些常用的方法?

    答:线程的常用方法如下:

    • currentThread():返回当前正在执行的线程引用
    • getName():返回此线程的名称
    • setPriority()/getPriority():设置和返回此线程的优先级
    • isAlive():检测此线程是否处于活动状态,活动状态指的是程序处于正在运行或准备运行的状态
    • sleep():使线程休眠
    • join():等待线程执行完成
    • yield():让同优先级的线程有执行的机会,但不能保证自己会从正在运行的状态迅速转换到可运行的状态
    • interrupted():是线程处于中断的状态,但不能真正中断线程

    4.wait() 和 sleep() 有什么区别?

    答:wait() 和 sleep() 的区别主要体现在以下三个方面。

    • 存在类的不同:sleep() 来自 Thread,wait() 来自 Object。
    • 释放锁:sleep() 不释放锁;wait() 释放锁。
    • 用法不同:sleep() 时间到会自动恢复;wait() 可以使用 notify()/notifyAll() 直接唤醒。

    5.守护线程是什么?

    答:守护线程是一种比较低级别的线程,一般用于为其他类别线程提供服务,因此当其他线程都退出时,它也就没有存在的必要了。例如,JVM(Java 虚拟机)中的垃圾回收线程。

    6.线程有哪些状态?

    答:在 JDK 8 中,线程的状态有以下六种。

    • NEW:尚未启动
    • RUNNABLE:正在执行中
    • BLOCKED:阻塞(被同步锁或者 IO 锁阻塞)
    • WAITING:永久等待状态
    • TIMED_WAITING:等待指定的时间重新被唤醒的状态
    • TERMINATED:执行完成

    题目分析:JDK 8 线程状态的源码如下图所示:

    3e132ba272cfa91dc677a8eff76f79b9.png
    98ca994099428ed21fe35be9670d527e.gif

    7.线程中的 start() 和 run() 有那些区别?

    答:start() 方法用于启动线程,run() 方法用于执行线程的运行时代码。run() 可以重复调用,而 start() 只能调用一次。

    8.产生死锁需要具备哪些条件?

    答:产生死锁的四个必要条件:

    • 互斥条件:一个资源每次只能被一个线程使用;
    • 请求与保持条件:一个线程因请求资源而阻塞时,对已获得的资源保持不放;
    • 不剥夺条件:线程已获得的资源,在末使用完之前,不能强行剥夺;
    • 循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系;

    这四个条件是死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之一不满足,就不会发生死锁。

    9.如何预防死锁?

    答:预防死锁的方法如下:

    • 尽量使用 tryLock(long timeout, TimeUnit unit) 的方法 (ReentrantLock、ReentrantReadWriteLock),设置超时时间,超时可以退出防止死锁;
    • 尽量使用 Java. util. concurrent 并发类代替自己手写锁;
    • 尽量降低锁的使用粒度,尽量不要几个功能用同一把锁;
    • 尽量减少同步的代码块。

    10.thread.wait() 和 thread.wait(0) 有什么区别?代表什么含义?

    答:thread.wait() 和 thread.wait(0) 是相同的,使用 thread.wait() 内部其实是调用的 thread.wait(0),源码如下:

    public final void wait() throws InterruptedException {    wait(0);}
    98ca994099428ed21fe35be9670d527e.gif

    wait() 表示进入等待状态,释放当前的锁让出 CPU 资源,并且只能等程序执行 notify()/notifyAll() 方法才会被重写唤醒。

    11.如何让两个程序依次输出 11/22/33 等数字,请写出实现代码?

    答:使用思路是在每个线程输出信息之后,让当前线程等待一会再执行下一次操作,具体实现代码如下:

    new Thread(() -> {    for (int i = 1; i  {    for (int i = 1; i 
    98ca994099428ed21fe35be9670d527e.gif

    程序执行结果如下:

    线程一:1

    线程二:1

    线程二:2

    线程一:2

    线程二:3

    线程一:3

    12.说一下线程的调度策略?

    答:线程调度器选择优先级最高的线程运行,但是如果发生以下情况,就会终止线程的运行:

    • 线程体中调用了 yield() 方法,让出了对 CPU 的占用权;
    • 线程体中调用了 sleep() 方法,使线程进入睡眠状态;
    • 线程由于 I/O 操作而受阻塞;
    • 另一个更高优先级的线程出现;
    • 在支持时间片的系统中,该线程的时间片用完。

    总结

    程序的运行依靠的是进程,而进程的执行依靠的是多个线程,多线程之间可以共享一块内存和一组系统资源,而多进程间通常是相互独立的。线程的创建有三种方式:继承 Thread 重写 run 方法,实现 Runnable 或 Callable 接口,其中 Callable 可以允许线程的执行有返回值,JDK 8 中也可以使用 Lambda 来更加方便的使用线程,线程是有优先级的,优先级从 1-10 ,数字越大优先级越高,也越早被执行。如果两个线程各自拥有一把锁的同时,又同时等待获取对方的锁,就会造成死锁。可以降低锁的粒度或减少同步代码块的范围或使用 Java 提供的安全类,来防止死锁的产生。

    下一篇:Java 线程池

    在公众号菜单中可自行获取专属架构视频资料,包括不限于 java架构、python系列、人工智能系列、架构系列,以及最新面试、小程序、大前端均无私奉献,你会感谢我的哈

    往期精选(全集在wx公号【架构师修炼】)

    分布式数据之缓存技术,一起来揭开其神秘面纱

    分布式数据复制技术,今天就教你真正分身术

    数据分布方式之哈希与一致性哈希,我就是个神算子

    分布式存储系统三要素,掌握这些就离成功不远了

    想要设计一个好的分布式系统,必须搞定这个理论

    分布式通信技术之发布订阅,干货满满

    分布式通信技术之远程调用:RPC

    消息队列Broker主从架构详细设计方案,这一篇就搞定主从架构

    消息中间件路由中心你会设计吗,不会就来学学

    消息队列消息延迟解决方案,跟着做就行了

    秒杀系统每秒上万次下单请求,我们该怎么去设计

    【分布式技术】分布式系统调度架构之单体调度,非掌握不可

    CDN加速技术,作为开发的我们真的不需要懂吗?

    烦人的缓存穿透问题,今天教就你如何去解决

    分布式缓存高可用方案,我们都是这么干的

    每天百万交易的支付系统,生产环境该怎么设置JVM堆内存大小

    你的成神之路我已替你铺好,没铺你来捶我

    展开全文
  • 当我们说起某个人很nice的时候,通常指的是那个人心地善良,很说话,很容易相处。(相反,aggressive的人很可能是不nice的,因为老想抢夺别人的东西,尤其是在资源有限的情况下,恨不得一个蛋糕吃掉90%以上。所以...

    当我们说起某个人很nice的时候,通常指的是那个人心地善良,很好说话,很容易相处。(相反,aggressive的人很可能是不nice的,因为老想抢夺别人的东西,尤其是在资源有限的情况下,恨不得一个蛋糕吃掉90%以上。所以我们要远离那些为了自己的利益而不顾一切的人。)

    言归正传,还是先看看"nice"是怎么定义的,在book 《Linux Kernel Development》 (3rd Edition) Page#44中,

     

    The Linux kernel implements two separate priority ranges.The first is the nice value, a number from –20 to +19 with a default of 0. Larger nice values correspond to a lower priority—you are being "nice" to the other processes on the system. Processes with a lower nice value (higher priority) receive a larger proportion of the system’s processor compared to processes with a higher nice value (lower priority). ...<snip>...

    译文:Linux内核实现了两种不同的优先级范围。第一种是用nice值,它的范围是[-20, 19],默认值是0。越大的nice值意味着优先级越低--你对系统中的别的进程"nice"。相比于那些高nice值(低优先级)的进程来说,低nice值(高优先级)的进程可以获得更多的处理器时间。

     

    在生活(或工作)中,一个人越nice,说明他越好说话,那么他的诉求就越容易被更晚一些予以满足。在操作系统中,如果一个进程越nice, 说明它很好说话,说明它不着急使用CPU, 那它就可以被抢占,反正很nice呗,于是优先级就越低。在一个资源有限的环境中,越nice的人得到的利益保证通常是滞后的,谁让你好说话呢?!在一个操作系统中(CPU资源有限),越nice的进程得到CPU的时间同样是滞后的,谁让你不着急呢?!(哪怕你正在CPU上run着呢,一个比你不nice的进程闯进来了,你就得从CPU上被调度器给撸下来,等待下次被调度。)

    归根结底一句话,会叫的孩子有奶吃,越是不nice的进程越有CPU优先使用权(也就是优先级高咯)。

     

    转载于:https://www.cnblogs.com/idorax/p/6279024.html

    展开全文
  • Java线程优先级

    2017-04-09 16:32:38
    操作系统基本采用时分的调度运行线程,操作系统会分出一个个时间片,线程会被分配到若干个时间片,当线程的时间片用完了就会发生线程调度,并且等待着下次调度,线程被分配到的...默认是5,优先级越高越好。 public


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

    在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-09-27 17:06:02
    优先级队列和普通队列并没有特大的不同之处,不一样的地方是,...数值越小,优先级越高。ps:这和按一定规则排序队列没啥区别啊。 实现如下 //header.h#ifndef _HEADER_H #define _HEADER_H #include<...
  • 权重(即优先级)的规则如下,权重越高,优先级越高:  同一个元素可以使用多个规则来指定它的同一样式(比如字体颜色),每个规则都有自己的选择器。显然最终只有一个规则起作用(不可能一个
  • 进程优先级

    2017-05-03 22:10:16
    PRI :进程优先权,代表这个进程可被执行的优先级,其值越小,优先级越高,越早被执行 NI :进程Nice值,代表这个进程的优先值 %nice :改变过优先级的进程的占用CPU的百分比 (呵呵,这句难理解是吧,不急...
  • linux系统进程优先级

    2019-04-06 17:56:41
    优先级值越低,优先级越高,就越快被调度程序选中。 另外,优先级还影响分配给进程的时间片长短。重要的进程,应该分配多一些cpu时间片,让其尽快完成任务。所有的进程都会有机会运行,但高优先级重要的进程会...
  • 为aop设置优先级

    2017-11-29 18:11:55
    优化:AOP切面的优先级 由于通过AOP实现,程序得到了很的解耦,但是也会带来一些问题,比如:我们可能会对Web层做多个...i的值越小,优先级越高。假设我们还有一个切面是CheckNameAspect用来校验name必须为didi,
  • 随着生活水平的不断提高,人们对于精神需要的寄托来来深,休闲娱乐产业一定会越来越,游戏建模行业的前景也是看得到的。 很多新手入行都遇到过跟你一样的问题:我应该先学什么软件?比较下手一点的,怎么学...
  • OSPF路由协议的Distance值为110,它拥有一个Metric值,此值是OSPF路由协议用来衡量链路好坏的,当一条链路的Metric值越小,则证明此条链路越好,反之此条链路越差。 路由协议按数据传输方式分,分为有类(Classfu.....
  • 在表格中位置越靠下的运算符优先级越高优先级越高的越优先计算。 如果优先级一样则自左向右计算。 Python官方提供的优先级的表格:我们安装Python的解释器就在本地有一份官方文档了。 官方文档位置:[开始] —&...
  • 淘汰顺序的凭据就是系统进程的优先级了,优先级越高越不容易被杀死,反之亦然。系统总共为进程分了五个优先级,如下 一、前台进程(进程满足如下任一条件即为前台进程): 1. 拥有 一个执行了onresume方法正在与用户...
  • 随着生活水平的不断提高,人们对于精神需要的寄托来来深,休闲娱乐产业一定会越来越,游戏建模行业的前景也是看得到的。 很多新手入行都遇到过跟你一样的问题:我应该先学什么软件?比较下手一点的,怎么学...
  • 学习Android最好的途径当然是强大的官方文档了,其中在Processes and Threads一节中对于进程...淘汰顺序的凭据就是系统进程的优先级了,优先级越高越不容易被杀死,反之亦然。系统总共为进程分了五个优先级,如下 一、
  • 通常,优先级数越低,进程的优先级越高。 人们可能会对优先级数字感到困惑,因此在GATE中,明确提到哪一个是最高优先级,哪一个是最低优先级。示例在例子中,有7个进程:P1,P2,P3,P4,P5,P6和P7。 它们的优先级...
  • 此处的基本数据类型就是int型、double型、char型等可以直接使用的数据类型,优先队列对它们的优先级设置一般是数字大的优先级越高,因此队首元素就是优先队列内元素最大的那个(如果char型,则是字典序最大的)。...
  • 动态优先级算法(java实现)

    千次阅读 2019-11-02 14:13:53
    Java实现动态优先级算法算法导入实验要求实验流程图算法分析算法设计算法调试结尾感言 算法导入 最近在学操作系统,老师的第一个实验要求...注:数字越小,优先级越高,当然我偷懒都设为正整数,你好我大家!...
  • 进程优先级,nice理解

    2018-10-14 13:39:11
    PRI :进程优先权,代表这个进程可被执行的优先级,其值越小,优先级越高,越早被执行 NI :进程Nice值,代表这个进程的优先值 %nice :改变过优先级的进程的占用CPU的百分比 (呵呵,这句难理解是吧,不急慢....
  • PRI :进程优先权,代表这个进程可被执行的优先级,其值越小,优先级越高,越早被执行; NI :进程Nice值,代表这个进程的优先值; %nice :改变过优先级的进程的占用CPU的百分比。 PRI是比较理解的,即进程的...
  • OSPF原理和优先级(学习笔记)

    千次阅读 2020-04-21 16:05:40
    一,原理概述 (1)ospf是基于链路状态的动态路由协议 (2)特点: 具有区域化(area)的层次结构,扩展性,收敛速度快。 (3)网络类型: 广播网络(Broadcast) ...优先级越高的路由器选为D...
  • 用top或者ps命令会输出PRI/PR、NI这两种指标值,这些到底是什么东西...PRI是比较理解的,即进程的优先级,或者通俗点说就是程序被CPU执行的先后顺序,此值越小进程的优先级别越高。 那NI呢?就是我们所要说的nic...
  • 上海域格模块RNDIS拨号网络优先级设置 高通模块需要RNDIS拨号版本,ASR默认RNDIS拨号。 方法一: ...跃点数越小,即优先级越高。如下图: 2、设置后就可以按照设置的顺序进行网络上网连接。 ...
  • PRI :进程优先权,代表这个进程可被执行的优先级,其值越小,优先级越高,越早被执行 NI :进程Nice值,代表这个进程的优先值 %nice :改变过优先级的进程的占用CPU的百分比 (呵呵,这句难理解是吧,不急慢慢...
  • 关于优先级队列的实现

    千次阅读 2009-01-05 15:48:00
    经朋友的指点,终于想到一个非常简单的实现方法,那就是把优先级比较的插入一个队列,优先级低的插入另一个队列,取数的时候先在优先级高的队列上取数。这有个缺点就是如果优先级别多的话,队列就多。 因为要...
  • 经朋友的指点,终于想到一个非常简单的实现方法,那就是把优先级比较的插入一个队列,优先级低的插入另一个队列,取数的时候先在优先级高的队列上取数。这有个缺点就是如果优先级别多的话,队列就多。  因为...
  • CPU的时钟频率可以简单的认为是执行一条指令的速度,频率越高,速度越快,性能越好。调度器是什么:就是一种策略,你去火车站买票,你会思索去哪个队买票,这就是一种非常简单的调度行为。那么调度行为必然存在主动...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 183
精华内容 73
关键字:

优先级越高越好