Java基础之线程调度与线程创建方式二

调度策略

时间片

抢占式：高优先级的线程抢占CPU

Java的调度方法

同优先级线程组成先进先出队列（先到先服务），使用时间片策略

对高优先级，使用优先调度的抢占式策略

线程的优先级等级

MAX_PRIORITY：10

MIN _PRIORITY：1

NORM_PRIORITY：5

 涉及的方法

getPriority() ：返回线程优先值

setPriority(int newPriority) ：改变线程的优先级

 说明

线程创建时继承父线程的优先级

低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

获取当前线程优先及

Thread.currentThread().getPriority()获取当前线程优先及

 class My extends Thread{
    public My(){}
    public My(String name){//构造器
        super(name);

    }
    @Override
    public void run() {
        for (int i =0;i<10;i++){
            if (i %2==0){
                try {
                    sleep(1000);//休眠一秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+i+":"+Thread.currentThread().getPriority());
            }
            if(i%3==0){
                yield();
            }
        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) throws InterruptedException {
        My m1 = new My();
        m1.setName("线程1***");//设置线程的名字
        m1.start();
        Thread.currentThread().setName("主线程");
        for (int i =0;i<10;i++){
            if (i%2==0){

                System.out.println(Thread.currentThread().getName()+":"+i);

            }
            if (i==2){
                try {
                    m1.join();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }


            }
        }
        System.out.println(m1.isAlive());//判断m1线程是否存活

    }
}
测试结果
主线程:0
主线程:2
线程1***0:5
线程1***2:5
线程1***4:5
线程1***6:5
线程1***8:5
主线程:4
主线程:6
主线程:8
false

Process finished with exit code 0

　　测试

class My extends Thread{
    public My(){}
    public My(String name){//构造器
        super(name);

    }
    @Override
    public void run() {
        System.out.println("子线程");
        System.out.println(getName());
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) throws InterruptedException {
        My m1 = new My();
        //设置子线程优先级
        m1.setPriority(Thread.MAX_PRIORITY);
        m1.setName("线程1***");//设置线程的名字
        m1.start();

        Thread.currentThread().setName("主线程");
        for (int i =0;i<10;i++){
            if (i%2==0){

                System.out.println(Thread.currentThread().getName()+":"+i);

            }
            if (i==2){
                try {
                    m1.join();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }


            }
        }
        System.out.println(m1.isAlive());//判断m1线程是否存活

    }
}
测试
主线程:0
子线程
主线程:2
线程1***
主线程:4
主线程:6
主线程:8
false

Process finished with exit code 0

　　线程的调度。最后重复10（线程安全为题）

class window extends Thread{
    private static int tic = 10;
    @Override
    public void run() {
         while (true){
             if (tic>0){
                 System.out.println(getName()+tic);
                 tic--;
             }else {
                 break;
             }
         }

    }
}
public class windowTest {
    public static void main(String[] args) {

        window w1 = new window();
        window w2 = new window();
        window w3 = new window();
        w1.setName("1---");
        w2.setName("2---");
        w3.setName("3----");
        w1.start();
        w2.start();
        w3.start();
    }

}
测试结果
3----10
1---10
2---10
1---8
3----9
1---6
1---4
1---3
1---2
2---7
1---1
3----5

Process finished with exit code 0

　　创建实现多线程的方式二实现Runnable 接口、

创建一个实现Runnable接口的类

实现类去实现Runnable中的抽象方法：run（）

创建实现类的对象

将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

通过Thread类的对象去调用start()

/**
 * 创建多线程的方式2：实现Runnable方式
 * 创建一个实现runnable接口的方法
 * 创建实现类的对象
 * 将此对象Thread类的对象调用start()
 *
 */
//创建一个实现Runnable接口类
class Mthread implements Runnable{

    @Override
    public void run() {
        for (int i = 0 ;i<10;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }

}
public class ThreadTest {
    public static void main(String[] args) {
        Mthread mthread= new Mthread();
        Thread t1= new Thread(mthread);
        t1.start();

    }
}
测试结果
0
2
4
6
8

Process finished with exit code 0

　　售票小窗的实现

package com.chenxi.java2;

class win1 implements Runnable{
    private  int Tic= 10;
    @Override
    public void run() {
        while (true){
            if (Tic>0){
                System.out.println(Thread.currentThread().getName()+":"+Tic);
                Tic--;
            }else {
                break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        win1 w1= new win1();
        Thread t1 = new Thread(w1);
        Thread t3 = new Thread(w1);
        Thread t2 = new Thread(w1);
        t1.start();
        t2.start();
        t3.start();
    }
}
测试结果
Thread-0:10
Thread-1:10
Thread-2:10
Thread-2:7
Thread-2:6
Thread-2:5
Thread-2:4
Thread-1:8
Thread-1:2
Thread-1:1
Thread-0:9
Thread-2:3

Process finished with exit code 0

　　开发中优先选择实现Runnable接口的方式

1.天然适合处理共享数据

2.没有类的单继承局限

发现Thread 基础Runnable方式

相同 两种方式都需要Run(),将线程的方式run方法里