本篇内容介绍了“Java多线程怎么设置优先级”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
举例说明：
我们知道飞机在天上飞行是有固定的航线（可以理解成线程），每个机场都有最大的运行负载能力，当运行情况超过了负载能力的时候，这就需要塔台调度参与，会根据每架飞机的优先级排序。当在航线的时候，如果出现紧急情况，会让其他飞机避让，让这架飞机优先级提高，先降落。这就是调度，计算机程序线程运行也是这样的。
在Java多线程中，主要可以通过下面四个方法来分配CPU的使用权：
设置优先级（Priority） 设置线程的优先级，值是1-10
休眠（sleep） 单位毫秒，让本线程属于阻塞状态，CPU会执行其他线程
强制运行（join） 让这个线程强制获取CPU资源来运行
礼让（yield） 暂停正在执行的线程，让其他线程先执行，执行完了在接着执行
有两个线程，分别设置最大优先级和最小优先级：
计算
安全
数据库
网络和加速
企业服务
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();
}
}结果：
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();
}
}
}
}结果：
顾名思义，就是让某个线程强制进入执行：
子线程：
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);
}
}
}结果：
暂停正在执行的线程，让其他线程先执行，执行完了在接着执行：
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();
}
}结果：
定时器就是可以设置某个时间点来执行某个事件，比如系统每周删除依次日志文件，或者在指定的日期关闭系统，定时器本身就是一个线程任务来在指定的时候执行该任务。定时器是继承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);
}
}结果：
首先我们先看一个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("国");
}
}
“Java多线程怎么设置优先级”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！
亿速云「云服务器」，即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘，价格低至29元/月。点击查看>>
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
