Java多线程怎么设置优先级

举例说明：

我们知道飞机在天上飞行是有固定的航线（可以理解成线程），每个机场都有最大的运行负载能力，当运行情况超过了负载能力的时候，这就需要塔台调度参与，会根据每架飞机的优先级排序。当在航线的时候，如果出现紧急情况，会让其他飞机避让，让这架飞机优先级提高，先降落。这就是调度，计算机程序线程运行也是这样的。

1、线程的调度：

在Java多线程中，主要可以通过下面四个方法来分配CPU的使用权：

• 设置优先级（Priority） 设置线程的优先级，值是1-10

• 休眠（sleep） 单位毫秒，让本线程属于阻塞状态，CPU会执行其他线程

• 强制运行（join） 让这个线程强制获取CPU资源来运行

• 礼让（yield） 暂停正在执行的线程，让其他线程先执行，执行完了在接着执行

1、设置优先级（Priority）：

有两个线程，分别设置最大优先级和最小优先级：

public class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行："+i);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread(),"线程A：");
        Thread t2 = new Thread(new MyThread(),"线程B***：");

        //设置优先级： 最高为10  最低为1
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);

        //显示线程优先级：
        System.out.println("线程A的优先级是："+t1.getPriority());
        System.out.println("线程B的优先级是："+t2.getPriority());

        t1.start();
        t2.start();
    }
}

结果：

2、休眠（sleep）

Thread.sleep();--------单位是毫秒，让本线程属于阻塞状态，CPU会执行其他线程：

public class ThreadSleep {
    public static void main(String[] args) {
        sleepTime(5);
    }

    private static void sleepTime(int time) {
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行了："+i+"s");
            try{
                //让线程休眠，进入阻塞状态
                Thread.sleep(1000); //休眠时间为1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

3、强制运行（join）

顾名思义，就是让某个线程强制进入执行：

子线程：

public class MyThread {
}

测试类：

public class Test {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=  new Thread(new MyThread(),"我是子线程");
        t1.start();
        //当主线程执行任务1-10时，如果执行到5就让子线程t1强制进来执行，直到执行完了才让主线程继续执行任务
        for (int i = 0; i < 6; i++) {
            if (i==2){
                t1.join();
            }
            System.out.println(Thread.currentThread().getName()+"正在运行："+i);
        }
    }
}

结果：

4、礼让（yield）

暂停正在执行的线程，让其他线程先执行，执行完了在接着执行：

public class MyThread implements Runnable{

    //线程礼让，让本线线程阻塞，其他线程先执行
    //这里就是A线程运行二次后，礼让，让B 线程先执行
    //也是理论上的，就是不管怎么样第二次后面肯定让B先执行，但是后面就随机了
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行："+i);
            if(i == 2){
                Thread.yield();
            }
        }
    }
}

测试类：

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

        Thread t1 = new Thread(new MyThread(),"线程A:");
        Thread t2 = new Thread(new MyThread(),"----线程B");

        t1.start();
        t2.start();
    }
}

结果：

2、定时器线程：

定时器就是可以设置某个时间点来执行某个事件，比如系统每周删除依次日志文件，或者在指定的日期关闭系统，定时器本身就是一个线程任务来在指定的时候执行该任务。定时器是继承TimerTask来重写run方法，专门处理定时任务。

演示Demo:

public class MyThread extends TimerTask {

    @Override
    public void run() {
        //把任务定义在run方法中
        showMyself();
    }

    public void showMyself(){
        System.out.println("被Run方法执行的");
    }
}

测试类：

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

        Timer timer = new Timer();

        //设置5秒后执行这个任务，并且每1秒重复执行这个任务

        timer.schedule(new MyThread(),5000,1000);

    }
}

结果：

3、线程的同步：

首先我们先看一个demo：

创建了两个线程对象，一个线程A任务用于执行print1,另一个线程B任务用于执行print2：

public void print1(){
        System.out.print("中");
        System.out.println("国");
    }

    public void print2(){
        System.out.print("浙");
        System.out.println("江");
    }
}

测试类：

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

        Printer p = new Printer();
        //A:
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    p.print1();
                }
            }
        },"线程A：").start();

        //B:
        new Thread("线程B："){
            @Override
            public void run(){
                while (true){
                    p.print2();
                }
            }
        }.start();
    }
}

这个程序就是当线程A执行的时候，输出中国，当B执行的时候，输出浙江，理论上是没有任何问题，但是我们看一下结果：

我们发现出问题了，其实这就是非线程同步（异步）：

• 同步：提交请求->等待服务器处理->处理完返回 这个期间客户端浏览器不能干任何事

• 异步：请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

其实非线程同步在有些系统是很危险的问题，比如12306，如果使用非线程同步，那么后果可想而知，那么该如何同步呢？ 这里介绍一个常用的方法，就是上锁：

如果两端代码(两个线程任务)是同步的，那么CPU同一时间只能执行一个任务,相当于给该线程上了一把锁， 在该线程没有执行完这段代码或者任务的时候，其他线程是不能占用CPU资源执行任务的。直到执行完了该线 程的代码，其他线程才可以执行。

更好的理解（举例）：

你去公共厕所上厕所（大的），当你进去后，需要把门关上并锁着，这就是上锁，为了保证你正常的结束（保证线程正常运行完），这期间其他人是不能进来的。

Synchronized 锁：

两个线程任务使用同一个对象为锁，那么两个线程方法是同步的 我们把上面的方法上个锁：

class Demo {
}

public class Printer {

   //创建任意一个对象，只要是对象相同就是锁相同，就是同步的！
    Demo d = new Demo();  

    public void print1(){
    	//当进入print1这个方法时，synchronized就给这个方法上了一个锁
        synchronized (d){     
            System.out.print("中");
            System.out.println("国");
        }
    }

    public void print2(){
        //当进入print2这个方法时，synchronized也给这个方法上了一个锁
        synchronized (d){
            System.out.print("浙");
            System.out.println("江");
        }
    }

}

这样输出后就不会出现上面的那个问题，这里就不发结果截图啦。大家可以自己试一试，看看是否解决了这个问题~

我们还可以把锁直接定义在方法上，比如这样子：

public static synchronized void print1(){
            System.out.print("中");
            System.out.println("国");
    }

如果是静态方法，上锁的方式是通过.class字节码对象：

public static void print1() {
        synchronized (Printer.class) {
            System.out.print("中");
            System.out.println("国");
        }
    }