Eu já vi muitas respostas para essa pergunta, mas ainda não tenho certeza.

Um deles era "Java é preemptivo". (A agenda JVM usa um algoritmo de planejamento preventivo baseado em prioridade (geralmente algoritmo round robin).

A segunda é que, se dois encadeamentos com a mesma prioridade, o Java não será precedido e um encadeamento poderá morrer de fome.

Então agora eu escrevi um programa para verificar, criei 10 threads com prioridade mínima seguidos por 10 threads com prioridade máxima, os resultados foram que eu pulei entre todos os threads - significando que Java é preemptivo mesmo que 2 threads estejam com o mesmo prioridade

 /*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @
 */
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        for (int i=0;i<10;i++){
            Thread t=new Thread(new Dog(i));
            t.setPriority(Thread.MIN_PRIORITY);
            t.start();
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException ex) {
            Logger.getLogger(JavaApplication1.class.getName()).log(Level.SEVERE, null, ex);
        }
        for (int i = 0; i < 10; i++) {
            Thread g = new Thread(new Dog(i+10));
            g.setPriority(Thread.MAX_PRIORITY);
            g.start();
        }

    }
}

t

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

/**
 *
 * @author Matan2t
 */
public class Dog implements Runnable{
    public int _x=-1;
    public Dog(int x){
        _x=x;
    }
    @Override
    public void run(){
        while(true){
            System.out.println("My Priority Is : " + _x);
        }
    }

}