Дросселирование использования ЦП/памяти потока в Java?

Если я понимаю вашу проблему, одним из способов было бы адаптивное засыпание потоков, аналогично воспроизведению видео в Java. Если вы знаете, что хотите использовать ядро ​​на 50%, ваш алгоритм должен спать примерно 0,5 секунды, потенциально распределяясь в течение секунды (например, вычисление 0,25 секунды, сон 0,25 секунды и т. д.). Вот пример из моего видеоплеера.

long starttime = 0; // variable declared
//...
// for the first time, remember the timestamp
if (frameCount == 0) {
    starttime = System.currentTimeMillis();
}
// the next timestamp we want to wake up
starttime += (1000.0 / fps);
// Wait until the desired next time arrives using nanosecond
// accuracy timer (wait(time) isn't accurate enough on most platforms) 
LockSupport.parkNanos((long)(Math.max(0, 
    starttime - System.currentTimeMillis()) * 1000000));

Этот код будет спать на основе значения кадров в секунду.

Чтобы ограничить использование памяти, вы можете обернуть создание объекта в фабричный метод и использовать какой-то семафор с ограниченными разрешениями в виде байтов, чтобы ограничить общий предполагаемый размер объекта (вам нужно оценить размер различных объектов, чтобы рационировать семафор). ).

package concur;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class MemoryLimited {
    private static Semaphore semaphore = new Semaphore(1024 * 1024, true);
    // acquire method to get a size length array
    public static byte[] createArray(int size) throws InterruptedException {
        // ask the semaphore for the amount of memory
        semaphore.acquire(size);
        // if we get here we got the requested memory reserved
        return new byte[size];
    }
    public static void releaseArray(byte[] array) {
        // we don't need the memory of array, release
        semaphore.release(array.length);
    }
    // allocation size, if N > 1M then there will be mutual exclusion
    static final int N = 600000;
    // the test program
    public static void main(String[] args) {
        // create 2 threaded executor for the demonstration
        ExecutorService exec = Executors.newFixedThreadPool(2);
        // what we want to run for allocation testion
        Runnable run = new Runnable() {
            @Override
            public void run() {
                Random rnd = new Random();
                // do it 10 times to be sure we get the desired effect
                for (int i = 0; i < 10; i++) {
                    try {
                        // sleep randomly to achieve thread interleaving
                        TimeUnit.MILLISECONDS.sleep(rnd.nextInt(100) * 10);
                        // ask for N bytes of memory
                        byte[] array = createArray(N);
                        // print current memory occupation log
                        System.out.printf("%s %d: %s (%d)%n",
                            Thread.currentThread().getName(),
                            System.currentTimeMillis(), array,
                            semaphore.availablePermits());
                        // wait some more for the next thread interleaving
                        TimeUnit.MILLISECONDS.sleep(rnd.nextInt(100) * 10);
                        // release memory, no longer needed
                        releaseArray(array);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        // run first task
        exec.submit(run);
        // run second task
        exec.submit(run);
        // let the executor exit when it has finished processing the runnables
        exec.shutdown();
    }
}

Уход за форумами Java. В основном синхронизируйте свое выполнение, а затем ждите, когда вы занимаете слишком много времени. Как упоминалось в исходном потоке, выполнение этого в отдельном потоке и прерывание рабочего потока даст более точные результаты, как и усреднение значений с течением времени.

import java.lang.management.*;

ThreadMXBean TMB = ManagementFactory.getThreadMXBean();
long time = new Date().getTime() * 1000000;
long cput = 0;
double cpuperc = -1;

while(true){

if( TMB.isThreadCpuTimeSupported() ){
    if(new Date().getTime() * 1000000 - time > 1000000000){ //Reset once per second
        time = new Date().getTime() * 1000000;
        cput = TMB.getCurrentThreadCpuTime();
    }

    if(!TMB.isThreadCpuTimeEnabled()){
        TMB.setThreadCpuTimeEnabled(true);
    }

    if(new Date().getTime() * 1000000 - time != 0)
        cpuperc = (TMB.getCurrentThreadCpuTime() - cput) / (new Date().getTime() *  1000000.0 - time) * 100.0;                  
    }
//If cpu usage is greater then 50%
if(cpuperc > 50.0){
     //sleep for a little bit.
     continue;
}
//Do cpu intensive stuff
}

Вы можете получить много информации об использовании ЦП и памяти через JMX, но я не думаю, что он допускает какие-либо активные манипуляции.

Для некоторого контроля использования ЦП вы можете использовать Thread.setPriority().

Что касается памяти, то не существует такой вещи, как память на поток. Сама концепция потоков Java означает разделяемую память. Единственный способ контролировать использование памяти — использовать параметры командной строки, такие как -Xmx, но нет возможности манипулировать настройками во время выполнения.

Если вы запускаете потоки в отдельном процессе, вы можете ограничить использование памяти и ограничить количество процессоров или изменить приоритет этих потоков.

Однако все, что вы делаете, скорее всего, приведет к увеличению накладных расходов и сложности, что часто приводит к обратным результатам.

Если вы не можете объяснить, почему вы хотите это сделать (например, у вас есть плохо написанная библиотека, которой вы не доверяете и для которой не можете получить поддержку), я бы посоветовал вам не делать этого.

Причина, по которой нелегко ограничить использование памяти, заключается в том, что существует только одна общая куча. Таким образом, объект, который используется в одном потоке, может использоваться в другом и не назначается тому или иному потоку.

Ограничение использования ЦП означает остановку всех потоков, чтобы они ничего не делали, однако лучший подход состоит в том, чтобы убедиться, что поток не тратит впустую ЦП и активно выполняет только ту работу, которую необходимо выполнить, и в этом случае вы бы не хочу остановить их делать это.

Вы можете назначать разные приоритеты потокам, чтобы наиболее релевантные потоки планировались чаще.

Посмотрите на этот ответ, чтобы узнать, поможет ли это.

Когда все запущенные потоки имеют одинаковый приоритет, они могут работать следующим образом:

t1, t2, t3,     t1, t2, t3,   t1, t2, t3

Когда вы назначаете другой приоритет одному из них, это может выглядеть так:

t1, t1, t1, t1,    t2,    t1, t1, t1 t3.

То есть первый поток выполняется «чаще», чем остальные.

Почему бы вместо «потоков» не использовать совместную многозадачность, было бы интересно посмотреть, сможете ли вы манипулировать http://www.janino.net/ для запуска программы в течение определенного времени/набора инструкций, затем остановите и запустите следующую программу. По крайней мере, так будет справедливо, дайте всем одинаковый кусок времени...

Thread.setPriority() может помочь, но не позволяет ограничивать ЦП, используемый потоком. На самом деле, я не слышал ни о какой библиотеке Java, которая делает это.

Возможно реализовать такую ​​возможность при условии, что ваши потоки готовы к взаимодействию. Суть в том, чтобы потоки периодически обращались к пользовательскому планировщику, а планировщик контролировал использование ЦП потоком с помощью JMX. Но проблема в том, что если какой-то поток недостаточно часто вызывает планировщик, он вполне может превысить ограничения регулирования. И вы ничего не можете сделать с потоком, который застревает в цикле.

Другим теоретическим путем реализации было бы использование изолятов. К сожалению, вам будет трудно найти JVM общего назначения, реализующую изоляты. Кроме того, стандартные API позволяют управлять только изолятом, а не потоками внутри изолята.

Единственный способ ограничить использование ЦП потока — либо заблокировать ресурс, либо часто вызывать yield().

Это не ограничивает использование ЦП ниже 100%, но дает другим потокам и процессам больше временных интервалов.

Чтобы снизить нагрузку на ЦП, вы хотите засыпать свои потоки внутри обычных циклов if и while.

while(whatever) {
    //do something
    //Note the capitol 'T' here, this sleeps the current thread.
    Thread.sleep(someNumberOfMilliSeconds);
}

Спящий режим в течение нескольких сотен миллисекунд значительно снизит загрузку процессора практически без заметного влияния на производительность.

Что касается памяти, я бы запустил профилировщик для отдельных потоков и немного настроил производительность. Если вы перекрыли объем памяти, доступной для потока, я думаю, что скорее всего возникнет исключение нехватки памяти или голодный поток. Я бы доверил JVM предоставить столько памяти, сколько нужно потоку, и работать над сокращением использования памяти, оставляя в области видимости только важные объекты в любой момент времени.