🌺个人主页：Dawn黎明开始
🎀系列专栏：Java
⭐每日一句：夜色难免黑凉，前行必有曙光📢欢迎大家：关注🔍+点赞👍+评论📝+收藏⭐️
文章目录
一.🔐线程的调度
1.1🔓定义
1.2🔓线程的优先级
1.1.1🔑说明
1.1.2🔑实例练习
1.3🔓线程的调度
1.3.1🔑线程休眠
1.3.2🔑线程插队
1.3.3🔑线程让步
1.3.4🔑中断线程
二.🔐线程的生命周期和状态转换
一.🔐线程的调度
1.1🔓定义
程序中的多个线程是并发执行的，但并不是同一时刻执行，某个线程若想被执行必须要得到CPU的使用权。Java虚拟机会按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制被称作线程的调度。
1.2🔓线程的优先级
1.1.1🔑说明
在应用程序中，要对线程进行调度，最直接的方式就是设置线程的优先级。优先级越高的线程获得CPU执行的机会越大，而优先级越低的线程获得CPU执行的机会越小。
注意
(1). 线程默认优先级是5。
(2).线程优先级的范围是：1-10。
(3).线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。
如何获取线程对象的优先级?
* public final int getPriority():返回线程对象的优先级
* 如何设置线程对象的优先级呢?
* public final void setPriority(int newPriority)：更改线程的优先级。
除了可以直接使用数字表示线程的优先级，还可以使用Thread类中提供的三个静态常量表示线程的优先级。
说明：程序在运行期间，处于就绪状态的每个线程都有自己的优先级，例如main线程具有普通优先级。
使用：可以通过Thread类的setPriority(int newPriority)方法对其进行设置，该方法中的参数newPriority接收的是1~10之间的整数或者Thread类的三个静态常量。
1.1.2🔑实例练习
代码如下👇🏻
package Process2;
public class ThreadPriority implements Runnable {
@Override
public void run() {
for(int i=0;i<200;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}package Process2;
public class ThreadPriorityDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
ThreadPriority tp = new ThreadPriority();
Thread tp1 = new Thread(tp, "aaa");
Thread tp2 = new Thread(tp, "bbb");
Thread tp3 = new Thread(tp, "ccc");
// 获取默认优先级
System.out.println(tp1.getPriority());
System.out.println(tp2.getPriority());
System.out.println(tp3.getPriority());
// 设置线程的优先级
tp1.setPriority(Thread.MAX_PRIORITY);
tp2.setPriority(Thread.MIN_PRIORITY);
tp1.start();
tp2.start();
tp3.start();
}
}
运行结果👇🏻
1.3🔓线程的调度
1.3.1🔑线程休眠
说明
(1).如果想要人为地控制线程执行顺序，使正在执行的线程暂停，将CPU使用权让给其他线程，这时可以使用静态方法sleep(long millis)。
(2).该方法可以让当前正在执行的线程暂停一段时间，进入休眠等待状态，这样其他的线程就可以得到执行的机会。
(3).sleep(long millis)方法会声明抛出InterruptedException异常，因此在调用该方法时应该捕获异常，或者声明抛出该异常。
* public static void sleep(long millis)
代码如下👇🏻
package Process2;
import java.util.Date;
public class ThreadSleep extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + ":" + i + "" + new Date());
// 休眠
// 困了，我稍微休息1秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package Process2;
public class ThreadSleepDemo {
public static void main(String[] args) {
ThreadSleep ts1 = new ThreadSleep();
ThreadSleep ts2 = new ThreadSleep();
ThreadSleep ts3 = new ThreadSleep();
ts1.setName("AAA");
ts2.setName("BBB");
ts3.setName("CCC");
ts1.start();
ts2.start();
ts3.start();
}
}
运行结果👇🏻
1.3.2🔑线程插队
说明
(1).在Thread类中也提供了一个join()方法来实现线程插队功能。
* public final void join():线程插队，等待该线程终止后其它线程才能执行。
(2).当在某个线程中调用其他线程的join()方法时，调用的线程将被阻塞，直到被join()方法加入的线程执行完成后它才会继续运行。
(3).Thread类中还提供了带有时间参数的线程插队方法join(long millis)。当执行带有时间参数的join(long millis)进行线程插队时，必须等待插入的线程指定时间过后才会继续执行其他线程。
代码如下👇🏻
package Process2;
public class ThreadJoin implements Runnable {
@Override
public void run() {
for(int i=0;i<5;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}package Process2;
public class ThreadJoinDemo {
public static void main(String[] args) throws InterruptedException {
ThreadJoin th = new ThreadJoin();
Thread tj1 = new Thread(th,"AAA");
Thread tj2 = new Thread(th,"BBB");
Thread tj3 = new Thread(th,"CCC");
tj3.start();
tj3.join();
tj1.start();
tj2.start();
}
}运行结果👇🏻
1.3.3🔑线程让步
说明
(1).线程让步可以通过yield()方法来实现，该方法和sleep(long millis)方法有点类似，都可以让当前正在运行的线程暂停，区别在于yield()方法不会阻塞该线程，它只是将线程转换成就绪状态，让系统的调度器重新调度一次。
(2).当某个线程调用yield()方法之后，与当前线程优先级相同或者更高的线程可以获得执行的机会。
* public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
* 让多个线程的执行更和谐，但是不能靠它保证一人一次。
代码如下👇🏻
package Process2;
public class ThreadYield implements Runnable {
@Override
public void run() {
for (int i = 0; i <10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
Thread.yield();
}
}
} package Process2;
public class ThreadYieldDemo {
public static void main(String[] args) {
ThreadYield th = new ThreadYield();
Thread ty1 = new Thread(th, "AAA");
Thread ty2 = new Thread(th, "BBB");
ty1.start();
ty2.start();
}
}运行结果👇🏻
1.3.4🔑中断线程
* public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。
代码如下👇🏻
package Process2;
import java.util.Date;
public class ThreadInterrupt implements Runnable {
@Override
public void run() {
System.out.println("线程开始执行：" + new Date());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
System.out.println("线程被终止了");
}
System.out.println("线程结束执行：" + new Date());
}
}
package Process2;
public class ThreadInterruptDemo {
public static void main(String[] args) throws InterruptedException {
ThreadInterrupt ti = new ThreadInterrupt();
Thread t = new Thread(ti, "线程终止！");
t.start();
Thread.sleep(3000);
t.interrupt();
}
}运行结果👇🏻
二.🔐线程的生命周期和状态转换
说明
(1).在Java中，任何对象都有生命周期，线程也不例外，它也有自己的生命周期。
(2).当Thread对象创建完成时，线程的生命周期便开始了。
(3).当线程任务中代码正常执行完毕或者线程抛出一个未捕获的异常（Exception）或者错误（Error）时，线程的生命周期便会结束。
