Как можно присвоить потоку приоритет?

Как можно присвоить потоку приоритет

В Java каждый поток имеет приоритет от 1 до 10, который влияет на то, как часто планировщик потоков (Thread Scheduler) выделяет ему время процессора. Приоритет устанавливается через метод setPriority() класса Thread.

Уровни приоритета

Для удобства Java предоставляет три константы:

public class Thread {
    public static final int MIN_PRIORITY = 1;      // Минимальный
    public static final int NORM_PRIORITY = 5;     // По умолчанию
    public static final int MAX_PRIORITY = 10;     // Максимальный
}

Базовое использование

Thread thread = new Thread(() -> {
    System.out.println("Поток выполняется");
});

// Установка приоритета до запуска
thread.setPriority(Thread.MAX_PRIORITY);
thread.start();

// Чтение текущего приоритета
int currentPriority = thread.getPriority();
System.out.println("Приоритет потока: " + currentPriority);

Примеры различных приоритетов

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // Поток с максимальным приоритетом (важная задача)
        Thread highPriorityThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("[HIGH] Итерация " + i);
            }
        }, "HighPriorityThread");
        highPriorityThread.setPriority(Thread.MAX_PRIORITY);
        
        // Поток с нормальным приоритетом
        Thread normalPriorityThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("[NORMAL] Итерация " + i);
            }
        }, "NormalPriorityThread");
        normalPriorityThread.setPriority(Thread.NORM_PRIORITY);
        
        // Поток с минимальным приоритетом (фоновая задача)
        Thread lowPriorityThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("[LOW] Итерация " + i);
            }
        }, "LowPriorityThread");
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
        
        // Запуск всех потоков
        highPriorityThread.start();
        normalPriorityThread.start();
        lowPriorityThread.start();
    }
}

Установка приоритета в Runnable

public class WorkerTask implements Runnable {
    private final String name;
    private final int priority;
    
    public WorkerTask(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }
    
    @Override
    public void run() {
        Thread.currentThread().setPriority(this.priority);
        System.out.println(name + " запущен с приоритетом " + 
            Thread.currentThread().getPriority());
        
        // Основная логика
        for (int i = 0; i < 3; i++) {
            System.out.println(name + ": " + i);
        }
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(new WorkerTask("Task-1", Thread.MAX_PRIORITY));
        Thread t2 = new Thread(new WorkerTask("Task-2", Thread.NORM_PRIORITY));
        Thread t3 = new Thread(new WorkerTask("Task-3", Thread.MIN_PRIORITY));
        
        t1.start();
        t2.start();
        t3.start();
    }
}

Работа с потоками в ExecutorService

Для управления приоритетами в thread pool создай ThreadFactory:

import java.util.concurrent.*;

public class PriorityThreadFactory implements ThreadFactory {
    private final int priority;
    private final String namePrefix;
    private int threadNumber = 0;
    
    public PriorityThreadFactory(int priority, String namePrefix) {
        this.priority = priority;
        this.namePrefix = namePrefix;
    }
    
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r, namePrefix + "-" + (++threadNumber));
        thread.setPriority(this.priority);
        thread.setDaemon(false);
        return thread;
    }
}

public class ExecutorServiceExample {
    public static void main(String[] args) {
        // Поток pool для высокоприоритетных задач
        ExecutorService highPriorityExecutor = Executors.newFixedThreadPool(
            2,
            new PriorityThreadFactory(Thread.MAX_PRIORITY, "HIGH")
        );
        
        // Поток pool для низкоприоритетных задач
        ExecutorService lowPriorityExecutor = Executors.newFixedThreadPool(
            2,
            new PriorityThreadFactory(Thread.MIN_PRIORITY, "LOW")
        );
        
        // Отправка задач
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            highPriorityExecutor.execute(() -> {
                System.out.println("HIGH priority task " + taskId);
            });
            lowPriorityExecutor.execute(() -> {
                System.out.println("LOW priority task " + taskId);
            });
        }
        
        highPriorityExecutor.shutdown();
        lowPriorityExecutor.shutdown();
    }
}

Практические сценарии использования

1. Приоритезация UI потоков:

class UIUpdateTask implements Runnable {
    @Override
    public void run() {
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        // Обновление пользовательского интерфейса
        updateUI();
    }
}

2. Фоновые задачи с низким приоритетом:

class BackgroundCleanupTask implements Runnable {
    @Override
    public void run() {
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        
        while (true) {
            try {
                // Очистка кэша
                cleanCache();
                Thread.sleep(60000); // 1 минута
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
}

3. Динамическое изменение приоритета:

public class AdaptivePriorityThread extends Thread {
    private volatile int workload = 0;
    
    @Override
    public void run() {
        while (!isInterrupted()) {
            // Динамическое изменение приоритета в зависимости от нагрузки
            if (workload > 80) {
                setPriority(Thread.MAX_PRIORITY);
            } else if (workload > 50) {
                setPriority(Thread.NORM_PRIORITY);
            } else {
                setPriority(Thread.MIN_PRIORITY);
            }
            
            // Логика работы
            processTask();
        }
    }
    
    public void setWorkload(int workload) {
        this.workload = workload;
    }
}

Важные замечания и ограничения

1. Приоритет НЕ гарантирует порядок выполнения:

// Поток с MAX_PRIORITY может ждать, если другие потоки имеют lock
Object lock = new Object();
synchronized(lock) {
    // Даже высокоприоритетный поток будет ждать
    Thread.sleep(5000);
}

1. ОС может переопределить приоритет:

// На некоторых ОС (Windows, Linux) приоритеты Java могут не отражать
// реальные приоритеты системы
thread.setPriority(Thread.MAX_PRIORITY);

1. Daemon потоки:

Thread daemonThread = new Thread(() -> {
    System.out.println("Background work");
});
daemonThread.setDaemon(true);
daemonThread.setPriority(Thread.MIN_PRIORITY);
daemonThread.start();

1. Избегай экстремальных приоритетов:

// ❌ Опасно использовать MAX_PRIORITY везде
for (int i = 0; i < 100; i++) {
    Thread t = new Thread(task);
    t.setPriority(Thread.MAX_PRIORITY); // Плохо
    t.start();
}

// ✅ Используй приоритеты разумно
Thread urgentTask = new Thread(criticalTask);
urgentTask.setPriority(Thread.MAX_PRIORITY);

Best Practices

1. Используй приоритеты в исключительных случаях — большинству задач подходит NORM_PRIORITY
2. Документируй причину использования MAX_PRIORITY — почему эта задача критична
3. Тестируй поведение на целевой платформе — приоритеты работают по-разному на разных ОС
4. Предпочитай другие синхронизационные механизмы — ReentrantLock, Semaphore, CountDownLatch часто лучше, чем манипуляция приоритетами
5. Мониторь производительность — изменение приоритетов может привести к дефициту времени на одних потоках

Итоги

• Приоритеты задаются через setPriority() (1-10)
• Константы: MIN_PRIORITY (1), NORM_PRIORITY (5), MAX_PRIORITY (10)
• Приоритеты — подсказка для планировщика, не гарантия
• Используй ThreadFactory для управления приоритетами в ExecutorService
• Будь осторожен: неправильное использование может снизить производительность