关于线程的调度

1.常见的线程调度模型

　　（1）抢占式调度模型

　　　　　　哪个线程的优先级比较高，抢到的CPU时间片的概率就大。java采用的就是抢占式调度模型。

　　（2） 均分式调度模型

　　　　　　平均分配CPU时间片，每个线程占有的CPU时间片长度一样，平均分配，一切平等。有一些编程语言采用的是这种方式。

2.java中提供了哪些方法和线程调度有关系的？

　　2.1 实例方法

　　　　（1）void setPriority(int newPriority)    设置线程的优先级

　　　　（2）int getPriority()   获取线程优先级

　　　　   最低优先级：1；最高优先级：10；默认优先级：5

　　　　　优先级高的获取CPU时间片很大概率会多一些

　　　　（3）void join()    合并线程

　　　　

class MyThread1 extends Thread{
        public void doSome(){
            Mythread2 t=new MyThread2();
            t.join();  //当前线程进入阻塞，t线程执行，直到t线程结束，当前线程才可以继续。(相当于把多线程变成单线程)
            
        }
    }
    
    class MyThread2 extends Thread{
        
    }

 

　　2.2 静态方法

　　　　　　static void yield()     让位方法：暂停当前正在执行的线程对象，并执行其他线程

　　　　　　注：yield()方法不是阻塞方法，yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”，但是回到就绪之后有可能会再次抢到

3. 代码延时

　　（1）

package XianChengFenXi;

/*
 * 关于线程的优先级
 */
public class ThreadTest11 {
    
    public static void main(String[] args){
        
        System.out.println("最高优先级"+Thread.MAX_PRIORITY);
        System.out.println("最低优先级"+Thread.MIN_PRIORITY);
        System.out.println("默认优先级"+Thread.NORM_PRIORITY);
        
        //获取当前线程对象，获取当前线程的优先级
        Thread currentThread=Thread.currentThread();
        currentThread.getName();
        //currentThread.setPriority(1); //将主线程的优先级设为1
        
        //main线程的默认优先级是：5
        System.out.println(currentThread.getName()+"线程的默认优先级是："+currentThread.getPriority());
        
        Thread t=new Thread(new MyRunnable5());
        t.setName("t");
        t.start();
        
    
    }
    
}

class MyRunnable5 implements Runnable{
    public void run(){
        //获取线程的优先级,默认优先级也是5
        System.out.println(Thread.currentThread().getName()+"线程的默认优先级是："+Thread.currentThread().getPriority());
        
    }
}

运行结果：

　　

（2）优先级设置及测试

package XianChengFenXi;

/*
 * 关于线程的优先级
 */
public class ThreadTest11 {
    
    public static void main(String[] args){
        
        //获取当前线程对象，获取当前线程的优先级
        Thread currentThread=Thread.currentThread();
        currentThread.setPriority(1); //将主线程的优先级设为1
        
        Thread t=new Thread(new MyRunnable5());
        t.setName("t");
        t.setPriority(10); //将分支线程的优先级设为10
        t.start();
        System.out.println(currentThread.getName()+"线程的设置后的优先级是："+currentThread.getPriority());
        for(int i=0;i<10;i++){
            System.out.println("主线程--------"+i);
        }
    
    }
    
}

class MyRunnable5 implements Runnable{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"线程的设置后的优先级是："+Thread.currentThread().getPriority());
        for(int i=0;i<10;i++){
            System.out.println("分支线程++++++++++"+i);
        }
    
        
    }
}

运行结果：

　　（3）让位测试

　　

package XianChengFenXi;


/*
 * 让位：将当前线程暂停，使其回到就绪状态，让给其他线程
 */
public class ThreadTest12 {
    
    public static void main(String[] args){
        Thread t=new Thread(new MyRunnable6());
        t.setName("t");
        t.start();
        for(int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+"------"+i);
        }
    }

}

class MyRunnable6 implements Runnable{
    
    public void run(){
        for(int i=1;i<=100;i++){
            //每10个让位1次
            if(i%10==0){
                Thread.yield(); //当前线程暂停一下，让位给主线程
            }
            System.out.println(Thread.currentThread().getName()+"------"+i);
        }
        
    }
}

运行结果：

    

注：分支线程当运行到10的倍数让位给主线程，并不代表着到10了一定会运行主线程，因为分支线程虽然让位了，但是它还是会和主线程去竞争

　　（4）线程合并测试

　　

package XianChengFenXi;

public class ThreadTest13 {
    public static void main(String[] args){
        System.out.println("main begin:");
        
        Thread t=new Thread(new MyRunnable7());
        t.setName("t");
        t.start();
        
        //合并线程
        
        try {
            t.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } //将t合并到当前线程中，当前线程受阻塞，t线程开始执行，一直到结束
        System.out.println("main over:");
        
    }

}

class MyRunnable7 implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"------"+i);
        }
    }
}

运行结果：

注：合并的意思不是字面上的“将两个栈合并”，栈没有消失，而是两个栈之间发生了等待关系