标签: thread-priority

如果我在Eclipse中调试一些多线程Java代码 - 使用主类RunTest和一个有趣的类QueueListener.

假设:

• 初始化RunTest时 - QueueListener在后台运行.
• 当RunTest完成时 - QueueListener被终止
• RunTest中有一个方法 - 其中有一个断点
• QueueListener中有一个方法,其中包含断点
• QueueListener可以反复运行
• RunTest每次执行只运行一次(父类)

在Eclipse中调试时 - 两个断点都会出现.但Eclipse优先考虑RunTest - 我必须通过在调试器中选择该线程来手动将其翻转到QueueListener - 并反复重复这一过程.

有没有办法告诉Eclipse我对QueueListener更感兴趣,并认为testrunner是一个较低的优先级 - 当它选择显示调试断点时？

我的应用程序使用异步HttpWebRequest请求预取大量视频帧.因此,如果有100帧,预取器将异步请求所有100帧,一次全部请求,并在收到时进行处理.即它同时进行100次异步调用.这可能会使网卡饱和,但没关系.我想最大化网络带宽.

但是,当发生此预取时,用户可能想要查看其中一个帧.因此,假设他们想要查看第56帧.问题是,帧1 - 100已经被请求,并且在管道中,因此对帧56的请求可能需要很长时间才能得到响应.

如果有一些方法可以在完成asynch请求之后重新确定它们的优先级,那会更好.并将用户请求推送到队列的前面.

如果我不能这样做,我想我必须批量请求帧,以便我可以在批次之间插入我的用户请求,并避免超时.

关于如何正确设计这一点的任何想法都将非常感激.

我正在调查如何让我的Linux桌面体验保持流畅和交互,同时我在后台运行CPU密集型任务.这是我用来模拟CPU负载的示例程序(用Java编写):

public class Spinner {
    public static void main(String[] args)
    {
        for (int i = 0; i < 100; i++) {
            (new Thread(new Runnable() {
                    public void run() {
                        while (true);
                    }
            })).start();
        }
    }
}

当我在命令行上运行它时,我注意到我的桌面应用程序(例如文本编辑器)的交互性显着下降.我有一台双核机器,所以我并不为此感到惊讶.

为了解决这个问题,我的第一个想法是用这个过程很好renice -p 20 <pid>.然而,我发现这没有多大影响.相反,我必须使用ls /proc/<pid>/task | xargs renice 20 -p --具有更大效果的所有子进程.

我对此非常困惑,因为我不希望线程拥有自己的进程ID.即使他们这样做了,我也期望renice在整个过程中采取行动,而不仅仅是过程的主线.

有没有人清楚地了解这里发生了什么？ 似乎每个线程实际上是一个单独的进程(至少它有一个有效的PID).我知道历史上Linux就像这样工作,但我相信几年前NPTL已经解决了.

我正在测试RHEL 5.4(Linux内核2.6.18).

(sched_setscheduler(<pid>, SCHED_BATCH, ..)顺便说一句.如果我试图解决这个交互性问题,我会注意到同样的效果.也就是说,我需要对我所见的所有"子"进程进行调用/proc/<pid>/task,仅执行一次是不够的在主程序pid.)

我无法使用设置Pthread优先级pthread_attr_setschedparam().我试图解决这个问题,但无法解决.我还咨询了我的教科书,该教科书也使用相同的功能.我从书中复制了这段代码.你能告诉我如何设置线程优先级吗？

这是代码:

void *Func(void *arg);
int main()
{
pthread_t tid[5];

pthread_attr_t *tattr;
struct sched_param param;
int pr,error,i;

do
{
if( (tattr=(pthread_attr_t *)malloc(sizeof(pthread_attr_t)) )==NULL)
{
    printf("Couldn't allocate memory for attribute object\n");
}
}while(tattr==NULL);

if(error=pthread_attr_init(tattr))
{
    fprintf(stderr,"Attribute initialization failed with error %s\n",strerror(error));
}

for(i=0;i<5;i++)
{
    //scanf("%d",&pr);
        error = pthread_attr_getschedparam(tattr,&param);

        if(error!=0)
        {
            printf("failed to get priority\n");
        }

        param.sched_priority=10;
        error=pthread_attr_setschedparam(tattr,&param);

        if(error!=0)
        {
            printf("failed to set priority\n");
        }
/*  
    if(i%2==0)
    {
        if(error=pthread_attr_setdetachstate(tattr,PTHREAD_CREATE_DETACHED))

        {
            fprintf(stderr,"Failed to set thread attributes with error %s\n",strerror(error));
        }
    } …

如何使用GCD为自定义创建的串行异步队列设置高优先级？

我看了一下这个Q&A,其中建议使用dispatch_set_target_queue()&Pass High Priority Queue(DISPATCH_QUEUE_PRIORITY_HIGH)作为自定义串行异步队列的并发队列.

我的理解是,这将使串行队列上的所有任务同时执行.我的理解是否正确？如果是这样,什么是替代解决方案？

在Java中有没有办法为将调用对象doInBackground()方法的线程设置优先级SwingWorker？

在Thread API中有一个setPriority()方法.该SwingWorker.execute()方法调度swingworker以在工作线程上执行.我想访问该工作线程来设置它的优先级.

根据我的理解,这个工作线程来自一个默认的工作线程池.解决这个问题的唯一方法是使用我自己的执行者吗？

我已经编写了测试程序来测试SCHED_FIFO.我已经知道线程SCHED_FIFO无法取代SCHED_OTHER.但我无法解释同一个程序多次运行时获得的结果.

/* Includes */
#include <unistd.h>     /* Symbolic Constants */
#include <sys/types.h>  /* Primitive System Data Types */ 
#include <errno.h>      /* Errors */
#include <stdio.h>      /* Input/Output */
#include <stdlib.h>     /* General Utilities */
#include <pthread.h>    /* POSIX Threads */
#include <string.h>     /* String handling */
#include <sched.h>
/* prototype for thread routine */
void print_message_function ( void *ptr );
void print_message_function1 ( void *ptr );

/* struct to hold data to be passed …

我可以通过转到 /proc/$(pidof task)/ 并给出

猫状态。

有没有办法使用命令检查linux中的单个线程优先级？

问候，
学习者

我正在运行一个进程(在基于Linux 3.x的操作系统上),其中:

• 一些线程是'经理'线程(为简单起见,假设他们决定哪些工作线程应该做什么,但不做任何I/O和他们需要的CPU时间总共比工作者更短/更短线程)
• 更多的线程是"工人"线程:它们在计算方面做得很重,而且我在任何时候被抢占都没有问题.

可能存在超额订购(即,使用HT的英特尔处理器上的工作线程数超过核心的两倍).现在,我看到的是'经理'线程没有足够频繁地获得处理器时间.他们并非完全'挨饿',我只是想给他们一个提升.所以,我自然而然地想到设置不同的线程优先级(我在Linux上) - 但后来我注意到线程调度程序的不同选择及其效果.此时我感到困惑,或者更确切地说 - 我不清楚:

• 我应该为经理选择哪种调度策略,为工人选择哪种调度策略？
• 我应该将线程优先级设置为什么(如果有的话)？
• 我是否需要偶尔让我的线程产生()？

笔记:

• 我故意不再谈论语言或线程池机制.我想在更一般的环境中提出这个问题.
• 请不要对CPU核心做出假设.可能有很多,或者可能只有一个,也许我需要每个核心上的工人(或工人和经理).
• 工作线程可能会也可能不会执行I/O. 但是,对于他们没有做任何I/O的情况的答案是受欢迎的.
• 除了运行我的应用程序之外,我真的不需要系统响应很快.我的意思是,我宁愿能够在那里使用SSH,让我的打字回复给我,没有明显的延迟,但没有真正的限制.

例:

class MyThread extends Thread{  
public MyThread(String name) {
    super(name);
}

public void run(){
    for (int i=0; i<5; i++) {
        System.out.println(Thread.currentThread().getName()
                +"("+Thread.currentThread().getPriority()+ ")"
                +", loop "+i);
    }
} 
}; 

public class Demo {  
    public static void main(String[] args) {  

    System.out.println(Thread.currentThread().getName()
            +"("+Thread.currentThread().getPriority()+ ")");

    Thread t1=new MyThread("t1");    // t1
    Thread t2=new MyThread("t2");    // t2
    t1.setPriority(1);                // t1 priority 1
    t2.setPriority(10);                //t2 priority 10
    t1.start();                        // start t1
    t2.start();                        // start t2
}  
}

当我执行程序时,有时我输出如下:

//Output1
main(5)
t2(10), loop 0
t2(10), loop 1 …