자바 스레드 우선순위

Java 스레드 우선순위

Thread 클래스에서는 다음 속성을 사용하여 우선순위를 나타냅니다.

private int priority;

setPriority(int newPriority)를 통해 새로운 우선순위를 설정하고 getPriority()를 통해 스레드의 우선순위를 얻을 수 있습니다.

일부 정보는 다음 예를 통해 결론을 내립니다. Java 스레드의 기본 우선순위는 5입니다.

public static void main(String[] args) {
    Thread thread = new Thread();
    System.out.println(thread.getPriority());
}
// 打印结果：5

사실 이건 완전히 틀렸습니다. 아래 예시를 보면 현재 스레드의 우선순위도 4로 변경된 것을 알 수 있습니다.

public static void main(String[] args) {
    Thread.currentThread().setPriority(4);
    Thread thread = new Thread();
    System.out.println(thread.getPriority());
}

// 打印结果：4

실례입니다. 스레드의 기본 우선순위가 5라면 새로 생성된 스레드에는 5로 설정된 우선순위가 없지만 실제로는 4입니다. Thread 초기화 우선순위의 소스코드를 살펴보겠습니다.

Thread parent = currentThread();
this.priority = parent.getPriority();

스레드의 기본 우선순위는 상위 스레드의 우선순위를 상속하는 것으로 밝혀졌습니다. 위 예에서는 상위 스레드의 우선순위를 4로 설정했으므로 하위 스레드의 우선순위도 4가 됩니다.

엄밀히 말하면 하위 스레드의 기본 우선순위는 상위 스레드와 동일하며 Java 메인 스레드의 기본 우선순위는 5입니다.

Java에는 가장 낮은 우선순위(1), 보통 우선순위(5), 가장 높은 우선순위(10)의 세 가지 우선순위가 정의되어 있습니다. Java 우선순위 범위는 [1, 10]이며, 다른 숫자의 우선순위를 설정하면 IllegalArgumentException 예외가 발생합니다.

/**
 * The minimum priority that a thread can have.
 */
public final static int MIN_PRIORITY = 1;

/**
 * The default priority that is assigned to a thread.
 */
public final static int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public final static int MAX_PRIORITY = 10;

다음으로 스레드 우선순위의 역할에 대해 이야기해보겠습니다. 먼저 다음 코드를 살펴보겠습니다. 코드 로직은 3000개의 스레드를 생성하는 것입니다. 즉, 우선순위가 1인 1000개의 스레드, 우선순위가 5인 1000개의 스레드, 우선순위가 10인 1000개의 스레드입니다. minTimes를 사용하여 1000개 MIN_PRIORITY 스레드의 런타임 타임스탬프 합계를 기록하고, nortimes를 사용하여 1000개 NORM_PRIORITY 스레드의 런타임 타임스탬프 합계를 기록하고, maxTimes를 사용하여 1000개 MAX_PRIORITY 스레드의 런타임 타임스탬프 합계를 기록합니다. 각 우선순위 레벨의 실행 중인 타임스탬프의 합을 계산하여 값이 작을수록 우선순위가 높아집니다. 실행해서 살펴보겠습니다.

public class TestPriority {
    static AtomicLong minTimes = new AtomicLong(0);
    static AtomicLong normTimes = new AtomicLong(0);
    static AtomicLong maxTimes = new AtomicLong(0);

    public static void main(String[] args) {
        List<MyThread> minThreadList = new ArrayList<>();
        List<MyThread> normThreadList = new ArrayList<>();
        List<MyThread> maxThreadList = new ArrayList<>();

        int count = 1000;
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("min----" + i);
            myThread.setPriority(Thread.MIN_PRIORITY);
            minThreadList.add(myThread);
        }
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("norm---" + i);
            myThread.setPriority(Thread.NORM_PRIORITY);
            normThreadList.add(myThread);
        }
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("max----" + i);
            myThread.setPriority(Thread.MAX_PRIORITY);
            maxThreadList.add(myThread);
        }

        for (int i = 0; i < count; i++) {
            maxThreadList.get(i).start();
            normThreadList.get(i).start();
            minThreadList.get(i).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("maxPriority 统计：" + maxTimes.get());
        System.out.println("normPriority 统计：" + normTimes.get());
        System.out.println("minPriority 统计：" + minTimes.get());
        System.out.println("普通优先级与最高优先级相差时间：" + (normTimes.get() - maxTimes.get()) + "ms");
        System.out.println("最低优先级与普通优先级相差时间：" + (minTimes.get() - normTimes.get()) + "ms");

    }

    static class MyThread extends Thread {

        public MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(this.getName() + " priority: " + this.getPriority());
            switch (this.getPriority()) {
                case Thread.MAX_PRIORITY :
                    maxTimes.getAndAdd(System.currentTimeMillis());
                    break;
                case Thread.NORM_PRIORITY :
                    normTimes.getAndAdd(System.currentTimeMillis());
                    break;
                case Thread.MIN_PRIORITY :
                    minTimes.getAndAdd(System.currentTimeMillis());
                    break;
                default:
                    break;
            }
        }
    }
}

실행 결과는 다음과 같습니다.

# 第一部分
max----0 priority: 10
norm---0 priority: 5
max----1 priority: 10
max----2 priority: 10
norm---2 priority: 5
min----4 priority: 1
.......
max----899 priority: 10
min----912 priority: 1
min----847 priority: 5
min----883 priority: 1

# 第二部分
maxPriority 统计：1568986695523243
normPriority 统计：1568986695526080
minPriority 统计：1568986695545414
普通优先级与最高优先级相差时间：2837ms
最低优先级与普通优先级相差时间：19334ms

결과를 함께 분석해 보겠습니다. 먼저 첫 번째 부분을 살펴보겠습니다. 처음에 실행되는 스레드에는 높은 우선순위, 보통 우선순위, 낮은 우선순위가 있으며, 마지막에 실행되는 스레드에도 다양한 우선순위가 있음을 알 수 있습니다. 우선순위가 높은 스레드가 반드시 높은 우선순위를 의미하는 것은 아닙니다. 우선순위가 높은 스레드보다 우선순위가 낮은 스레드가 먼저 실행됩니다. 다른 말로 표현할 수도 있습니다. 코드 실행 순서는 스레드의 우선순위와 아무 관련이 없습니다. 두 번째 부분의 결과를 보면, 우선순위가 가장 높은 1000개의 스레드의 실행 타임스탬프의 합이 가장 작은 반면, 우선순위가 가장 낮은 1000개의 스레드의 실행 타임스탬프의 합이 가장 크다는 것을 알 수 있습니다. 따라서 우리는 다음을 알 수 있습니다. 우선순위가 높은 스레드 배치가 우선순위가 낮은 스레드 배치보다 먼저 실행됩니다. 즉, 우선순위가 높은 스레드가 우선순위가 낮은 스레드보다 CPU 리소스를 얻을 가능성이 더 높습니다.

각 운영 체제에는 실제로 10개의 스레드 수준이 있습니까?

크로스 플랫폼 언어인 Java에는 10가지 수준의 스레드가 있지만 운영 체제마다 매핑되는 스레드 우선 순위 값이 다릅니다. 다음으로 OpenJDK 소스코드에서 운영체제별 스레드 우선순위 매핑 값을 확인하는 방법을 알려드리겠습니다.

Thread 소스 코드를 보면 스레드 우선 순위를 설정하면 최종적으로 로컬 메서드 setPriority0()이 호출됩니다.

private native void setPriority0(int newPriority);

그러면 OpenJDK의 Thread.c 코드에서 setPriority0()에 해당하는 JVM_SetThreadPriority 메서드를 찾습니다.

static JNINativeMethod methods[] = {
    ...
    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
    ...};

찾습니다. JVM_SetThreadPriority 기반 jvm.cpp의 해당 코드 세그먼트

JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio))
  JVMWrapper("JVM_SetThreadPriority");
  // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
  MutexLocker ml(Threads_lock);
  oop java_thread = JNIHandles::resolve_non_null(jthread);
  java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio);
  JavaThread* thr = java_lang_Thread::thread(java_thread);
  if (thr != NULL) {                  // Thread not yet started; priority pushed down when it is
    Thread::set_priority(thr, (ThreadPriority)prio);
  }
JVM_END

3단계의 코드에 따르면 키가 java_lang_Thread::set_Priority() 코드임을 알 수 있으며 계속해서 thread.cpp 코드;

void Thread::set_priority(Thread* thread, ThreadPriority priority) {
  trace("set priority", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  // Can return an error!
  (void)os::set_priority(thread, priority);
}

위 내용은 자바 스레드 우선순위의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!