精华内容
下载资源
问答
  • 进程优先级/进程调度策略

    千次阅读 2018-07-12 09:36:50
    http://www.cnitblog.com/flutist1225/articles/19989.html 如何查看/设置/调整进程的... 修改为实时进程: chrt进程的nice值不是进程的优先级,他们不是一个概念,但是进程nice值会影响到进程的优先级变化。 5. ...

    http://www.cnitblog.com/flutist1225/articles/19989.html

     

    如何查看/设置/调整进程的优先级

    1.      查看:ps –l xxx

    2.      设置:nice

    3.      调整:renice

    4.      修改为实时进程: chrt

    进程的nice值不是进程的优先级,他们不是一个概念,但是进程nice值会影响到进程的优先级变化

     

    5.      API

    a)        nice

    b)       getpriority / setpriority

    这是(类似)nice命令的api, 取值范围是-20~19,这个和nice值一致。数值越低优先级越高。

    这个api可以针对PRIO_PROCESS,PRIO_PGRP, PRIO_USER.

    A child created by fork(2) inherits its parent's nice value.  The nice value is preserved across execve(2).

    c)        sched_getscheduler / sched_setscheduler

                            i.             设置进程的优先级,不同policy的进程,其优先级的取值范围不一样,可以通过sched_get_priority_min / sched_get_priority_max获取取值范围。同时,其对静态优先级也有要求。详见:man sched_setscheduler

    d)       Scheduling Policies

                            i.             SCHED_FIFO: First In-First Outscheduling. A FIFO-classed process will continue running as long as nohigher-priority process becomes runnable.

    a.        详见<Linux System Programing>


                          ii.             SCHED_RR: Round Robinscheduling. Each process is only allowed to run for a maximum time quantum. Ifa SCHED_RR process has been running for a time period equal to or longer thanthe time quantum, it will be put at the end of the list for its priority. (man sched_rr_get_interval)

                         iii.             SCHED_OTHER: Default Linux time-sharingscheduling

                         iv.             SCHED_BATCH: Scheduling batchprocesses

       不同调度策略的实时进程只有在相同优先级时才有可比性:

      1. 对于FIFO的进程,意味着只有当前进程执行完毕才会轮到其他进程执行。由此可见相当霸道。

      2. 对于RR的进程。一旦时间片消耗完毕,则会将该进程置于队列的末尾,然后运行其他相同优先级的进程,如果没有其他相同优先级的进程,则该进程会继续执行。

      总而言之,对于实时进程,高优先级的进程就是大爷。它执行到没法执行了,才轮到低优先级的进程执行。等级制度相当森严啊。

      Linux对普通的进程,根据动态优先级进行调度。而动态优先级是由静态优先级(static_prio)调整而来。Linux下,静态优先级是用户不可见的,隐藏在内核中。而内核提供给用户一个可以影响静态优先级的接口,那就是nice值,两者关系如下:

      static_prio=MAX_RT_PRIO+nice+ 20

      nice值的范围是-20~19,因而静态优先级范围在100~139之间。nice数值越大就使得static_prio越大,最终进程优先级就越低。

      系统调度时,还会考虑其他因素,因而会计算出一个叫进程动态优先级的东西,根据此来实施调度。例如如果进程属于交互式进程,那么可以适当的调高它的优先级,使得界面反应地更加迅速,从而使用户得到更好的体验。

      系统会严格按照动态优先级高低的顺序安排进程执行。动态优先级高的进程进入非运行状态或者时间片消耗完毕才会轮到动态优先级较低的进程执行。

     

    e)        Linux kernel中的prio相关宏

    #define MAX_USER_RT_PRIO     100

    #define MAX_RT_PRIO                  MAX_USER_RT_PRIO

     

    #define MAX_PRIO               (MAX_RT_PRIO+ 40)

    #define DEFAULT_PRIO                 (MAX_RT_PRIO+ 20)

     

    #define NICE_TO_PRIO(nice)       (MAX_RT_PRIO+ (nice) + 20)

    #define PRIO_TO_NICE(prio)       ((prio)- MAX_RT_PRIO - 20)

                            i.             优先级的取值范围是:0 ~ 140

                          ii.             实时进程的优先级取值范围:0 ~ 99

                         iii.             非实时进程的优先级取值范围:100 ~ 140

                         iv.             进程默认的优先级:120

                          v.             nice 与 prio的关系 (见上述转换宏)

    6.      动态优先级调整

    a)        打分

    b)       奖励,惩罚

    7.      红黑树优先级策略 (针对SCHED_OTHER类型的进程)  (CFS算法)

     

    实时进程吃CPU的时间也有控制, 系统会控制实时进程最多吃多少CPU, 可以通过proc调整这个比例:

    /proc/sys/kernel/sched_*


    展开全文
  • LinSched 最初是在北卡罗来纳大学开发的(IBM 和 Intel 提供赞助),但是最近又被 Google 恢复了,用来验证调度策略。这是有趣的举动,可能代表一种未来趋势。虽然 Linux 支持许多调度类并跨许多工作负荷进行了合理...
  • 当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么这个类就是线程安全的。 原子性:提供了...

    线程安全性

    当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么这个类就是线程安全的。

    • 原子性:提供了互斥访问,同一时刻只能有一个线程来对它进行操作
    • 可见性:一个线程对主内存的修改可以及时被其他线程观察到
    • 有序性:一个线程观察其他线程中的指令执行顺序,由于指令重排序的存在,该观察结果一般杂乱无序

    原子性

    原子性:提供了互斥访问,同一时刻只能有一个线程来对它进行操作

    • atomic包, 以Atomic开头的类,Java底层是使用CAS进行实现
      例如:AtomicInteger 调用了java底层的Unsafe.compareAndSwapInt方法,这里是实现CAS的关键,Unsafe类中调用的方法大多数是native,由jvm本地实现
    • AtomicLong、LongAdder
    • AtomicReference AtomicReferenceFieldUpdater
    @Slf4j
    @ThreadSafe
    public class AtomicExample4 {
    
        private static AtomicReference<Integer> count = new AtomicReference<>(0);
    
        public static void main(String[] args) {
            count.compareAndSet(0,2); // 2
            count.compareAndSet(0,1); // no
            count.compareAndSet(1,3); // no
            count.compareAndSet(2,4); // 4
            count.compareAndSet(3,5); // no
            log.info("count:{}",count.get());
        }
    }
    
    @Slf4j
    public class Test3 {
    
        private static AtomicReferenceFieldUpdater<Test3, Integer> updater = 
        AtomicReferenceFieldUpdater.newUpdater(Test3.class, Integer.class, "count");
    
        private volatile Integer count = 0; // 必须 非静态的 volatile 修饰的字段
    
        public static void main(String[] args) throws Exception{
            Test3 test3 = new Test3();
            updater.compareAndSet(test3, 0, 1);
            updater.compareAndSet(test3, 0, 2);
            updater.compareAndSet(test3, 1, 3);
            updater.compareAndSet(test3, 2, 4);
            log.info("结果:{}", updater.get(test3));
    
        }
    
    }
    
    • AtomicStampReference:CAS的ABA问题
      该类的核心方法compareAndSet,该类是通过一个重新定义一个stamp的值来标记当前值是否被更改过。

    • AtomicBoolean

    @Slf4j
    @ThreadSafe
    public class Test5 {
        // 请求总数
        private static int clientTotal = 5000;
        // 可同时执行的线程数
        private static int threadNum = 200;
        private static AtomicBoolean isHappen = new AtomicBoolean(false);
    
        public static void main(String[] args) throws Exception {
            final Semaphore semaphore = new Semaphore(threadNum);
            final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
            ExecutorService executorService = Executors.newCachedThreadPool();
    
            for (int i = 0; i < clientTotal; i++) {
                executorService.execute(() -> {
                    try {
                        semaphore.acquire();
                        update();
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    countDownLatch.countDown();
                });
    
            }
            countDownLatch.await();
            executorService.shutdown();
            log.info("ishappen:{}", isHappen.get());
        }
    
        private static void update() {
            if (isHappen.compareAndSet(false, true)) { // 只执行一次
                System.out.println("update exec");
            }
        }
    }
    

    可见性

    可见性:一个线程对主内存的修改可以及时的被其他线程观察到

    JMM关于synchronized的两条规定:

    • 线程解锁前,必须把共享变量的最新值刷新到主内存
    • 线程加锁时,将清空工作内存中共享变量的值,从而是用共享变量时需要从主内存中重新读取最新的值(注意,加锁与解锁是同一把锁)

    关于synchronized 影响可见性的问题

    synchronized

    • 修饰代码块:大括号括起来的代码,作用于调用的对象
    • 修饰方法:整个方法,作用于调用的对象
    • 修饰静态方法:整个静态方法,作用于所有对象
    • 修饰类,括号括起来的部分,作用于所有对象

    synchronized:不可中断锁,适合竞争不激烈,可读性好
    Lock:可中断锁,多样化同步,竞争激烈时能维持常态
    Atomic:竞争激烈时能维持常态,比Lock性能好,只能同步一个值

    volatile

    通过加入内存屏障和禁止重培训优化来实现:

    • 对于volatile变量写操作时,会在写操作后加入一条store屏障指令,将本地内存中的共享变量值刷新到主内存。
    • 对于volatile变量读操作时,会在读操作前加入一条load屏障指令,从主存中读取共享变量

    有序性

    Java内存模型中,允许编译器和处理器对指令进行重排序,但是重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性。

    有序性:一个线程观察其他线程中的指令执行顺序,由于指令重排序的存在,该观察结果一般杂乱无序

    如果两个操作执行的次序无法从happens-before原则中推导出来,那么就不能保证他们的有序性,jvm就可以随意的对他们进行重排序

    happen-before原则:

    1. 程序次序规则:在一个单独的线程中,按照程序代码的执行流顺序,(时间上)先执行的操作happen—before(时间上)后执行的操作。

    2. 管理锁定规则:一个unlock操作happen—before后面(时间上的先后顺序,下同)对同一个锁的lock操作。

    3. volatile变量规则:对一个volatile变量的写操作happen—before后面对该变量的读操作。

    4. 线程启动规则:Thread对象的start()方法happen—before此线程的每一个动作。

    5. 线程终止规则:线程的所有操作都happen—before对此线程的终止检测,可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止执行。

    6. 线程中断规则:对线程interrupt()方法的调用happen—before发生于被中断线程的代码检测到中断时事件的发生。

    7. 对象终结规则:一个对象的初始化完成(构造函数执行结束)happen—before它的finalize()方法的开始。

    8. 传递性:如果操作A happen—before操作B,操作B happen—before操作C,那么可以得出A happen—before操作C。

    volatile可以保证一定的有序性,不能保证原子性。

    synchronized,lock保证了单线程的运行,因此肯定时有序的

    安全策略

    不可变对象

    • Collections.unmodifiableXXX:Collection、List、Set、Map…
    • Guava:ImmutableXXX:Collection、List、Set、Map

    线程封闭

    • 堆栈封闭:局部变量,无并发问题
    • ThreadLocal 线程封闭:特别好的封闭方法
    1. 使用Filter将用户信息保存到ThreadLocal中
    2. 在业务方法中使用处理
    3. 使用拦截器(Inteceptor)在方法执行完后移除

    同步容器:

    • ArrayList -> Vector, Stack
    • HashMap -> HashTable(key, value不能为null)
    • Collections.SynchronizedXXX(List,Set,Map)

    并发容器

    • ArrayList -> CopyOnWriteArrayList
    • HashSet/TreeSet -> CopyOnWriteArraySet/ConcurrentSkipListSet
    • HashMap/TreeMap -> ConcurrentHashMap/ConcurrentSkipListMap

    最佳实践

    • 使用本地变量
    • 使用不可变类
    • 最小化锁的作用域范围
    • 使用线程池的Executor,而不是直接new Thread
    • 宁可使用同步也不要使用线程的wait和notify
    • 使用BlockingQueue实现生产-消费模式
    • 使用并发集合而不是加了锁的同步集合
    • 使用Semaphore创建有界的访问
    • 宁可使用同步代码块,也不使用同步的方法
    • 避免使用静态变量(使用时最好能加上final)
    展开全文
  • 这一部分讲解MySQL的默认的调度策略和可以用来影响这些策略的选项。它还谈到了并发性插入操作的使用和存储引擎锁定层次对客户端的并发性的影响。为了讨论的方便,我们把执行检索(SELECT)的客户端称为"读取者",把...

    DBA在日常工作中经常会遇到如何让单独的查询执行的速度更快。MySQL还允许你改变语句调度的优先级,它可以使来自多个客户端的查询更好地协作,这样单个客户端就不会由于锁定而等待很长时间。改变优先级还可以确保特定类型的查询被处理得更快。这一部分讲解MySQL的默认的调度策略和可以用来影响这些策略的选项。它还谈到了并发性插入操作的使用和存储引擎锁定层次对客户端的并发性的影响。为了讨论的方便,我们把执行检索(SELECT)的客户端称为"读取者",把执行修改操作(DELETE、INSERT、REPLACE或UPDATE)的客户端称为"写入者"。

    MySQL的默认的调度策略可用总结如下

    ◆写入操作优先于读取操作。

    ◆对某张数据表的写入操作某一时刻只能发生一次,写入请求按照它们到达的次序来处理。

    ◆对某张数据表的多个读取操作可以同时地进行。

    MyISAM和MEMORY存储引擎借助于数据表锁来实现这样的调度策略。当客户端访问某张表的时候,首先必须获取它的锁。当客户端完成对表的操作的时候,锁就会被解除。通过LOCK TABLES和UNLOCK TABLES语句来显式地获取或释放锁是可行的,但是在通常情况下,服务器的锁管理器会自动地在需要的时候获取锁,在不再需要的时候释放锁。获取的锁的类型依赖于客户端是写入还是读取操作。

    对某张表进行写入操作的客户端必须拥有独占的(排他的)访问权的锁。操作在进行的过程中,该数据表处于不一致的(inconsistent)状态,因为数据记录在删除、添加或修改的时候,数据表上的索引也可能需要更新以相互匹配。这个数据表在变化的过程中,如果允许其它的客户端访问,会出现问题。非常明显,允许两个客户端同时写入一张数据表是不利的,因为这样的操作会很快使数据表中的信息成为一堆无用的垃圾。但是允许客户端读取变化之中的数据表也不好,因为正在读取的位置中的数据可能正在变化(修改),读取的结果可能不是真实的。

    对某张表执行读取操作的客户端必须获取一个锁,防止在读取的过程中,其它的客户端写入或改变表。但是这个锁不需要独占的访问权。读取操作不会改变数据,因此没有理由让某个读取者阻止其它的读取者访问这张表。因此读取锁允许其它的客户端在同一时刻读取这张表。

    MySQL提供了几个语句调节符,允许你修改它的调度策略

    ◆LOW_PRIORITY关键字应用于DELETE、INSERT、LOAD DATA、REPLACE和UPDATE。

    ◆HIGH_PRIORITY关键字应用于SELECT和INSERT语句。

    ◆DELAYED关键字应用于INSERT和REPLACE语句。

    LOW_PRIORITY和HIGH_PRIORITY调节符影响那些使用数据表锁的存储引擎(例如MyISAM和MEMORY)。DELAYED调节符作用于MyISAM和MEMORY数据表。

    改变语句调度的优先级

    LOW_PRIORITY关键字影响DELETE、INSERT、LOAD DATA、REPLACE和UPDATE语句的执行调度。通常情况下,某张数据表正在被读取的时候,如果有写入操作到达,那么写入者一直等待读取者完成操作(查询开始之后就不能中断,因此允许读取者完成操作)。如果写入者正在等待的时候,另一个读取操作到达了,该读取操作也会被阻塞(block),因为默认的调度策略是写入者优先于读取者。当第一个读取者完成操作的时候,写入者开始操作,并且直到该写入者完成操作,第二个读取者才开始操作。

    如果写入操作是一个LOW_PRIORITY(低优先级)请求,那么系统就不会认为它的优先级高于读取操作。在这种情况下,如果写入者在等待的时候,第二个读取者到达了,那么就允许第二个读取者插到写入者之前。只有在没有其它的读取者的时候,才允许写入者开始操作。理论上,这种调度修改暗示着,可能存在LOW_PRIORITY写入操作永远被阻塞的情况。如果前面的读取操作在进行的过程中一直有其它的读取操作到达,那么新的请求都会插入到LOW_PRIORITY写入操作之前。

    SELECT查询的HIGH_PRIORITY(高优先级)关键字也类似。它允许SELECT插入正在等待的写入操作之前,即使在正常情况下写入操作的优先级更高。另外一种影响是,高优先级的SELECT在正常的SELECT语句之前执行,因为这些语句会被写入操作阻塞。

    如果你希望所有支持LOW_PRIORITY选项的语句都默认地按照低优先级来处理,那么请使用--low-priority-updates选项来启动服务器。通过使用INSERT HIGH_PRIORITY来把INSERT语句提高到正常的写入优先级,可以消除该选项对单个INSERT语句的影响。

    使用延迟插入操作

    DELAYED调节符应用于INSERT和REPLACE语句。当DELAYED插入操作到达的时候,服务器把数据行放入一个队列中,并立即给客户端返回一个状态信息,这样客户端就可以在数据表被真正地插入记录之前继续进行操作了。如果读取者从该数据表中读取数据,队列中的数据就会被保持着,直到没有读取者为止。接着服务器开始插入延迟数据行(delayed-row)队列中的数据行。在插入操作的同时,服务器还要检查是否有新的读取请求到达和等待。如果有,延迟数据行队列就被挂起,允许读取者继续操作。当没有读取者的时候,服务器再次开始插入延迟的数据行。这个过程一直进行,直到队列空了为止。

    感觉上LOW_PRIORITY和DELAYED是相似的,两者都允许数据行插入操作被延迟,但是它们对客户端操作的影响却有很大的差异。LOW_ PRIORITY强迫客户端等待,直到那些数据行可以被插入数据表。DELAYED允许客户端继续操作,服务器在内存中缓冲那些数据行,直到自己有时间处理它们。

    如果其它的客户端可能运行很长的SELECT语句并且你不希望阻塞,等待插入操作完成的时候,INSERT DELAYED就非常有用处了。客户端提交INSERT DELAYED的时候可能处理得很快,因为服务器只是简单地把要插入的数据行排队。

    但是,你也必须知道正常的INSERT与INSERT DELAYED行为之间的一些其它的差异。如果INSERT DELAYED语句包含语法错误,客户端会得到一个错误,但是却无法得到其它一些在正常情况下可以使用的信息。例如,当语句返回的时候,你无法依赖(得到)AUTO_INCREMENT(自动增长)值。同样,你无法得到唯一索引的副本数量。发生这种情况的原因在于插入操作在真正地被执行之前已经返回了状态信息。另一种可能出现的情况是,由于INSERT DELAYED语句的数据行都在内存中排队,当服务器崩溃或者使用kill -9退出的时候,数据行可能丢失(正常情况下,kill -TERM终止命令不会导致这种情况,因为服务器在退出之前会把数据行插入表中)。

    使用并发的插入操作

    MyISAM存储引擎有一条例外的规则,它允许读取者阻塞写入者。这种现象发生在MyISAM数据表中间没有"空洞"(可能是删除或更新数据行的结果)的情况下。当数据表没有"空洞"的时候,任何INSERT语句必然在末尾而不是中部添加数据行。在这种情况下,MySQL允许其它客户端在读取数据的同时向数据表添加数据行。这就是"并发性插入操作",因为它们同时发生,检索并没有被阻塞。

    如果你希望使用并发性插入操作,请注意下面一些事项:

    ◆在INSERT语句中不要使用LOW_PRIORITY调节符。它会引起INSERT经常被读取者阻塞,因此阻碍了并发性插入操作的执行。

    ◆如果读取者需要显式地锁定数据表以执行并发性插入操作,就应该使用LOCK TABLES ... READ LOCAL,而不是LOCK TABLES ... READ。LOCAL关键字会获取一个锁,允许并发性操作继续进行,因为它只能应用于数据表中已有的数据行,不会阻塞那些添加到末尾的新数据行。

    ◆LOAD DATA操作应该使用CONCURRENT调节符,允许该数据表上的SELECT语句同时执行。

    ◆中间包含了"空洞"的MyISAM数据表不能使用并发性插入操作。但是,你可以使用OPTIMIZE TABLE语句来整理该数据表的碎片。

    锁的层次和并发性

    前面讨论的调度调节符允许你改变默认的调度策略。其中的大部分内容都是介绍使用这些调节符来解决数据表层次(table-level)的锁引起的问题,这都是MyISAM和MEMORY存储引擎用来管理数据表争用的问题的。

    BDB和InnoDB存储引擎实现了不同层次的锁,所以其性能特征和对争用的管理是不同的。BDB引擎使用页面层次(page-level)的锁。InnoDB引擎使用数据行层次(row-level)的锁,但是只在必要的时候使用(在很多情况下,例如当读取操作都完成的时候,InnoDB可能根本就不使用锁)。

    存储引擎使用的锁的层次对客户端的并发操作有很大的影响。假设两个客户端都希望更新某个数据表中的一行。由于要执行更新,每个客户端都需要一个写入锁。对于MyISAM数据表,引擎会为第一个客户端分配一个锁,这会引起第二个客户端阻塞,直到第一个客户端完成操作。对于BDB数据表,它可以实现更大的并发性:两个更新操作会同步进行,除非两个数据行都位于同一个页面中。在InnoDB数据表中,并发性更高;只要两个客户端没有更新同一行,两个更新操作就能同时发生。

    一般的规则是,锁的层次越细微,并发性越好,因为只要客户端使用数据表的部分不同,那么使用表的客户端就可以更多。它实际暗示着不同的存储引擎适合于不同的语句混合(mixes):

    ◆MyISAM检索的速度非常快。但是使用表层次的锁可能成为混合的检索和更新环境中的问题,特别是检索倾向于长时间运行的时候。在这些条件下,更新可能需要等待很久才能进行。

    ◆当更新操作很多的时候,BDB和InnoDB数据表可以提供更好的性能。由于锁在页面或数据行层次进行,表被锁定的范围较小。这会减少锁的争用,提高并发性。

    在防止死锁(deadlock)方面,表层次的锁比细微层次的锁更有优势。使用表层次的锁的时候,死锁不会发生。服务器可以通过查看语句来检测需要的数据表,并提前锁定它们。而InnoDB和BDB数据表会发生死锁,因为这些存储引擎没有在事务开始的时候分配所有必要的锁。作为代替,在事务处理的过程中,当检测到需要锁的时候才分配。这就可能出现两个语句获取了锁,接着试图进一步获取锁(需要多个锁),但是这些锁却被对方保持着,等待对方释放。其结果是每个客户端都拥有一个锁,同时还需要利用其它的客户端拥有的锁才能继续执行。这会导致死锁,服务器必须终止其中一个事务。

    展开全文
  • YARN上调度器开发

    千次阅读 2014-03-12 20:04:55
    和Hadoop1一样,YARN也支持可插入式的调度方式。本文将介绍如何在源码的基础上修改调度策略,并将其应用至Hadoop2上,以修改CapacityScheduler为例,原理和过程如下。

        和Hadoop1一样,YARN也支持可插入式的调度方式。本文将介绍如何在源码的基础上修改调度策略,并将其应用至Hadoop2上,以修改CapacityScheduler为例,其原理和过程如下。

    原理

        Hadoop2编译好后的各组件生成的jar包会放在$HADOOP_HOME/share/hadoop目录,Hadoop运行过程中也会调用该文件夹下相应的jar包。因此修改源码后,将相应的组件导出为jar包并覆盖该文件夹的子目录相应的jar包即可。

         如果是调度器的话, 将$hadoop-2.3.0-src/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java包导出并覆盖到$HADOOP_HOME/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-2.3.0.jar即可。      

    步骤

    step1.源码编译,并导入Eclipse

         ubuntu下hadoop-2.2.0的源码编译,参照:http://mmicky.blog.163.com/blog/static/15029015420136224315566/。注意,编译前一定要装好第三方库,编译源码前,还需修改一个bug:修改文件$hadoop-2.3.0-src/hadoop-common-project/hadoop-auth/pom.xml中的

    <dependency>
       <groupId>org.mortbay.jetty</groupId> 
       <artifactId>jetty-util</artifactId>
       <scope>test</scope>
    </dependency>
    <dependency> 
       <groupId>org.mortbay.jetty</groupId>
       <artifactId>jetty</artifactId>
       <scope>test</scope> 
    </dependency>

         编译好后,即可将其导入到eclipse。导入后,会出现很多类或者方法找不到JAR包,为了解决这个问题,需要将第三方JAR包导入工程中。方法如下:右击Project名称,在弹出的快捷菜单中选择“Properties”命令,将会弹出一个界面,然后在该界面中一次选择“Java Build Path”——>“Libraries”——>“Add External JARS...”,将$hadoop-2.3.0-src/hadoop-dist/target/hadoop-2.3.0.tar.gz解压后生成的目录中share/hadoop目录下各个子目录中lib文件夹下的JAR包导入工程。

    step2.修改源码

         修改包“org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity”即可


    step3.覆盖

         将/hadoop-2.3.0-src/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java包导出并覆盖到$HADOOP_HOME/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-2.3.0.jar即可。 
    展开全文
  • 【Java并发编程】9.线程安全与性能的思考

    千次阅读 多人点赞 2020-04-01 16:22:50
    定义:Doug Lea 大佬说过 如果多线程情况下使用这个类,无论多线程如何使用和调度这个类,这个类总是表示出正确的行为,这个类就是线程安全的。 类的线程安全表现为: 操作的原子性,类似数据库事务。 内存的可见...
  • 线程安全如果多线程情况下使用这个类,无论多线程如何使用和调度这个类,这个类总是表示出正确的行为,这个类就是线程安全的。类的线程安全表现为:操作的原子性,类似数据库事务。内存的可见性,当前线程修改后其他...
  • 线程-面试考点

    2020-07-20 17:22:46
    1.Java中如何保证线程安全性 答:首先线程安全主要体现在以下三个部分: 原子性:提供互斥访问,同一时刻只能有一个线程对数据进行操作,(atomic,synchronized); 可见性:一个线程对主内存的修改可以及时地被...
  • CPU调度的最小单位 线程的优势 (1)如果设计正确,多线程程序可以通过提高处理器资源的利用率来提升系统吞吐率 (2)建模简单:通过使用线程可以讲复杂并且异步的工作流进一步分解成一组简单并且同步的...
  • windowsnt 技术内幕

    2014-04-09 20:47:17
    调度大型打印作业 为同一打印设备创建多个打印机 设置分割符页(Separator Page) 打印处理过程简介 删除文档 设置通知、优先级和打印时间 打印机的暂停、清除和重试 停止和重启动缓冲器服务 在Windows NT中修改打印机...
  • 2.5.5 当路由器接收的IP报文的TTL值等于1时,采取的策略是? 2.5.6 在NetWare 网络中,客户需要访问某个类型的服务器时,首先要发送一个 ()广播报文来寻找服务器? 2.5.7 IPX地址网络地址有( )个字节? 2.5.8...
  • linux集群应用实战

    热门讨论 2013-03-27 12:24:49
    通过srvctl添加/修改/删除rac数据库实例 第43讲 测试oracle rac数据库集群功能 课程目标: 通过测试oracle rac数据库集群功能,验证rac数据库是否已经正常工作 rac数据库负载均衡功能测试 故障透明切换功能测试
  • 深入浅出MySQL数据库开发、优化与管理维护

    千次下载 热门讨论 2014-01-21 15:48:01
     20.2.5 MyISAM的锁调度   20.3 InnoDB锁问题   20.3.1 背景知识   20.3.2 获取InnoDB行锁争用情况   20.3.3 nnoDB的行锁模式及加锁方法   20.3.4 InnoDB行锁实现方式   20.3.5 间隙锁(Next-...
  • 本书论述运用UML(统一建模语言)和模式进行对象建模的方法和技巧,重点讨论了如何使用面向对象的分析和设计技术来建造一个健壮的和易于维护的系统。 全书叙述清晰、图文并茂、实例丰富,是一部来自于大量经验的...
  • 基础33 ElasticSearch 手动建立和修改mapping 及 定制string类型数据是否分词 基础34 ElasticSearch mapping复杂数据类型以及object类型数据 基础35 ElasticSearch search api的基础语法 基础36 Elastic...
  • 第07节、任务调度平台路由策略 资料+源码.rar 0039-蚂蚁课堂(每特学院)-2期-SpringCloud微服务基础 第01节、网站架构演变过程 第02节、微服务架构概述 第03节、SpringCloud概述 第04节、服务注册与服务发现 第05节...
  • 11.5.7 修改备份集的保留策略 229 11.5.8 归档日志删除策略 231 11.5.9 重写configure exclude命令 232 11.5.10 使用backup命令检查数据库的错误 232 11.5.11 跳过脱机的、不可访问的或只读的数据文件 232 ...
  • 3.6.1 利用vi创建和修改文件 46 3.6.2 用head和tail命令移动 47 3.7 文本的提取和排序 48 3.7.1 使用grep匹配模式 48 3.7.2 剪切、粘贴和联结文本 49 3.8 shell脚本 50 3.8.1 shell程序介绍 51 3.8.2...
  • 观察Windows如何管理虚拟内存和物理内存;理解NTFS的操作和格式,诊断文件系统访问问题;从上往下查看Windows的网络栈,包括映射、API、名称解析和协议驱动程序;诊断引导问题,执行崩溃分析。 本书适合广大Windows...
  • 精通Oracle PL/SQL--详细书签版

    热门讨论 2012-08-21 13:06:28
    这一章展示了如何把数据库中的数据结构和PL/SQL程序中的数据结构最大限度地整合在一起,使代码健壮且易于修改。同时还讨论了如何更好地利用集合把数据从程序批量复制给数据库,抑或反之。  第5章:PL/SQL优化技巧。...
  • Guide 哥注:权限管理系统在企业级的项目中一般都是非常重要的,如果你需求去实际了解一个不错的权限系统是如何设计的话,推荐你可以参考下面这些开源项目。 Spring-Cloud-Admin :Cloud-Admin 是国内首个基于 ...
  • FAQ(持续更新)

    2021-01-08 12:27:51
    这个计算队列名可用于指导我们内部的调度策略。首先,只要有空闲计算线程可用,任务将实时调起,计算队列名不起作用。当计算线程无法实时调起每个任务的时候,那么同一队列名下的任务将按...
  • [Oracle.11g权威指南(第2版)].谷长勇.扫描版.pdf

    千次下载 热门讨论 2013-06-23 21:16:09
    14.3 表的分区策略 332 14.4 管理表分区 332 14.4.1 表分区管理的操作列表 332 14.4.2 表分区管理的操作实例 333 14.5 分区表联机重定义 336 14.6 创建索引分区 338 14.6.1 索引分区概念 338 14.6.2 本地索引分区 ...
  • §12.8.5 解释计划(Explain Plan)策略 156 §12.8.6 AUTOTRACE 实用程序 157 第13章 数据访问方法 160 §13.1 使用索引的访问方法 161 §13.1.1 何时创建索引 161 §13.1.2 索引列和表达式的选择 161 §13.1.3 选择...
  • 31、EJB包括(SessionBean,EntityBean)说出他们的生命周期,及如何管理事务的?  SessionBean: Stateless Session Bean 的生命周期是由容器决定的,当客户机发出请求要建立一个Bean的实例时,EJB容器不一定要创建...
  • RED HAT LINUX 6大全

    热门讨论 2011-10-21 18:46:06
    3.3 如何卸载LILO 21 3.4 LILO 疑难解答 21 3.5 小结 22 第4章 配置X Window系统,版本11 23 4.1 X Window系统 23 4.2 建立XFree86系统 24 4.3 配置XFree86系统 25 4.3.1 XF86Config文件 27 4.3.2 使用XConfigurator...
  • 17.3.1 添加或修改列的规则 287 17.3.2 创建只读表 288 17.3.3 更改当前使用的表 288 17.3.4 创建虚拟列 288 17.3.5 删除列 289 17.4 根据一个表创建另一个表 290 17.5 创建索引编排表 292 17.6 创建视图 ...
  • java 面试题 总结

    2009-09-16 08:45:34
    派生类可以从它的基类那里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要。 3.封装: 封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即...
  • 7.3.4 电子商务和Web的访问控制策略 135 7.4 统计数据库的安全性简介 136 7.5 流控制简介 137 7.6 加密和公钥构架 138 7.6.1 数据加密标准和高级加密标准 138 7.6.2 公钥加密 138 7.6.3 ...
  • 而所有的异步结果都是通过 “任务队列” 来调度。 消息队列中存放的是一个个的任务(task)。 规范中规定 task 分为两大类,分别是 macro task 和 micro task,并且每个 macro task 结束后&...

空空如也

空空如也

1 2 3
收藏数 43
精华内容 17
关键字:

如何修改调度策略