设置线程优先级
Java提供了一个线程调度器来监控程序启动后进去就绪状态的所有线程。线程调度器通过线程的优先级来决定调度哪些线程执行。一般来说，Java的线程调度器采用时间片轮转算法使多个线程轮转获得CPU的时间片。
线程可以划分优先级，优先级高的线程得到的CPU资源比较多，也就是CPU优先执行优先级高的线程对象中的任务。优先级具有随机性，不一定优先级高的有限制性。
优先级说明
- 当线程的优先级没有指定时，所有线程都携带普通优先级。
- 优先级可以用从1到10的范围指定。10表示最高优先级，1表示最低优先级，5是普通优先级。
- 优先级最高的线程在执行时被给予优先。但是不能保证线程在启动时就进入运行状态。
- 与在线程池中等待运行机会的线程相比，当前正在运行的线程可能总是拥有更高的优先级。
- 由调度程序决定哪一个线程被执行。
- t.setPriority()用来设定线程的优先级。
- 在线程开始方法被调用之前，线程的优先级应该被设定。
- 可以使用常量，如MIN_PRIORITY,MAX_PRIORITY，NORM_PRIORITY来设定优先级。
Thread类优先级源码
// 优先级
private int priority;
// 获取优先级
public final int getPriority() {
return priority;
}
// 设置优先级，java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率
public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}
/**
* 线程可以具有的最低优先级
*/
public final static int MIN_PRIORITY = 1;
/**
* 分配给线程的默认优先级。
*/
public final static int NORM_PRIORITY = 5;
/**
* 线程可以具有的最大优先级。
*/
public final static int MAX_PRIORITY = 10;
设置优先级案例
public class Test001 {
public static void main(String[] args) {
MyThread001 thread001 = new MyThread001();
// 设置优先级最高
thread001.setPriority(Thread.MAX_PRIORITY);
thread001.start();
// 设置优先级最低
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
// 打印优先级
System.out.println("thread001优先级："+thread001.getPriority());
System.out.println("Main 优先级："+Thread.currentThread().getPriority());
System.out.println(Thread.currentThread().getName() + "线程正在运行任务");
}
}
设置守护线程
在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。
用户线程：我们平常创建的普通线程。
守护线程：守护线程是一类比较特殊的线程，一般用于处理一些后台的工作，随着用户线程的销毁，守护线程也会随着销毁，比如JDK的垃圾回收线程。
使用场景
守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。
Java垃圾回收线程就是一个典型的守护线程，因为我们的垃圾回收是一个一直需要运行的机制，但是当没有用户线程的时候，也就不需要垃圾回收线程了，守护线程刚好满足这样的需求。
场景：某个用户线程在执行时，需要一个定时无线循环线程，去检测心跳，一旦用户线程结束，这个检测线程也需要关闭。如果不设置守护线程，那个这个检测线程将无法停止，此时可以这只设置这个线程为守护线程，随着业务线程的完成而自动退出。
使用案例
public class DaemonThreadTest001 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "正在检测心跳");
try {
Thread.sleep( 3_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"检测心跳任务线程");
// 设置为守护线程
t.setDaemon(true);
// 查看线程是否为守护线程
System.out.println(t.getName()+"是否守护线程"+t.isDaemon());
System.out.println(Thread.currentThread().getName()+"是否守护线程"+Thread.currentThread().isDaemon());
t.start();
try {
Thread.sleep( 20_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "线程任务运行结束");
}
}
注意事项
1、 设置守护线程的方法很简单，调用setDaemon方法即可，true代表守护线程，false代表正常线程；
2、 线程是否为守护线程和它的父线程有很大的关系，如果父线程是正常线程，则子线程也是正常线程，反之亦然，如果你想要修改它的特性则可以借助setDaemon方法isDaemon方法可以判断该线程是不是守护线程；
3、 setDaemon(true)必须在t.start()之前设置，否则会抛出IllegalThreadStateException异常；
获取线程ID
public long getId()获取线程的唯一ID,线程的ID在整个JVM进程中都会是唯一的。并且是从0开始逐次递增。在一个JVM进程启动的时候，实际上是开辟了很多个线程，自增序列已经有了一定的消耗，因此我们自己创建的线程可能并不是第0号线程。
// 获取线程长整型的 id,id 唯一
long id = t.getId();
获取当前线程
public static Thread currentThread()用于返回当前执行线程的引用。
// 获取当前正在执行的线程
Thread thread = Thread.currentThread();
设置线程休眠
sleep方法方法会使当前线程进人指定毫秒数的休眠，暂停执行，虽然给定了一个休眠的时间，但是最终要以系统的定时器和调度器的精度为准，休眠有一个非常重要的特性，那就是其不会放弃监视器锁的所有权。
sleep是一个静态方法，其有两个重载方法，其中一个需要传入毫秒数，另外一个既需要毫秒数也需要纳秒数。
在JDK1.5以后，JDK引入了一个枚举TimeUnit，其对sleep方法提供了很好的封装，使用它可以省去时间单位的换算步骤。
public static void sleep(long millis) throws InterruptedException
public static void sleep(long millis, int nanos) throws InterruptedException
案例：
// 休眠3秒
Thread.sleep(3_000);
TimeUnit.SECONDS.sleep(3);
线程yield
yield方法属于一种启发式的方法，其会提醒调度器我愿意放弃当前的CPU资源，如果CPU的资源不紧张，则会忽略这种提醒。调用yield方法会使当前线程从RUNNING状态切换到RUNNABLE状态，一般这个方法不太常用。主要是为了测试和调试。
public static native void yield();
yield和sleep的区别
1、 sleep会导致当前线程暂停指定的时间，没有CPU时间片的消耗；
2、 yield只是对CPU调度器的一个提示，如果CPU调度器没有忽略这个提示，它会导致线程上下文的切换；
3、 sleep会使线程短暂block，会在给定的时间内释放CPU资源；
4、 yield会使RUNNING状态的Thread进入RUNNABLE状态（如果CPU调度器没有忽略这个提示的话)；
5、 sleep几乎百分之百地完成了给定时间的休眠，而yield的提示并不能一定担保；
6、 一个线程sleep另一个线程调用interrupt会捕获到中断信号，而yield则不会；
设置线程上下文类加载器
@CallerSensitive
public ClassLoader getContextClassLoader() {
if (contextClassLoader == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,
Reflection.getCallerClass());
}
return contextClassLoader;
}
public void setContextClassLoader(ClassLoader cl) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}
public ClassLoader getContextClassLoader()获取线程上下文的类加载器，简单来说就是这个线程是由哪个类加器加载的，如果是在没有修改线程上下文类加载器的情况下，则保持与父线程同样的类加载器。
public void setContextClassLoader(ClassLoader cl)设置该线程的类加载器，这个方法可以打破JAVA类加载器的父委托机制，有时候该方法也被称为JAVA类加载器的后门。
线程中断
取消一个任务的执行，最好的，同时也是最合理的方法，就是通过中断。
// 打断线程
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}
// 判断当前线程是否被打断
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
// 测试某些线程是否已被中断
public boolean isInterrupted() {
return isInterrupted(false);
}
private native boolean isInterrupted(boolean ClearInterrupted);
interrupt()
调用sleep或wait方法时，会使得当前线程进入阻塞状态，而调用当前线程的interrupt方法，就可以打断阻塞。打断一个线程并不等于该线程的生命周期结束，仅仅是打断了当前线程的阻塞状态。一旦线程在阻塞的情况下被打断，都会抛出一个称为InterruptedException的异常。
中断标识
在一个线程内部存在着名为interrupt flag的标识，如果一个线程被interrupt，那么它的flag将被设置，但是如果当前线程正在执行可中断方法被阻塞时，调用interrupt方法将其中断，反而会导致flag被清除。
InterruptedException
wait方和sleep方法前线程被中断了会抛出InterruptedException，并且清除中断状态。但是并不会终止当前线程的执行，当前线程可以选择忽略这个异常。
无论是设置interrupt status 还是抛出InterruptedException，它们都是给当前线程的建议，当前线程可以选择采纳或者不采纳，它们并不会影响当前线程的执行。
至于在收到这些中断的建议后，当前线程要怎么处理，也完全取决于当前线程。
测试案例
public class InterruptThreadTest001 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "正在检测心跳");
System.out.println("中断状态" + Thread.interrupted());
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
// 被中断时 退出循环
e.printStackTrace();
break;
}
}
}
}, "检测心跳任务线程");
// 获取当前线程
t.start();
try {
Thread.sleep(20_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 中断
t.interrupt();
System.out.println(Thread.currentThread().getName() + "线程任务运行结束");
}
}线程join
在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
public final void join() throws InterruptedException
public final synchronized void join(long millis, int nanos)throws InterruptedException
public final synchronized void join(long millis)throws InterruptedException
测试案例
线程t2先启动，3秒后才启动t1，但是由于t2使用了t1.jion(),则会等待t1执行完毕后，t2才会执行后续代码。
public class JoinThreadTest001 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "正在检测心跳");
}, "线程001");
Thread t2 = new Thread(() -> {
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在检测心跳");
}, "线程002");
t2.start();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
t1.start();
}
}其他API
start()
启动一个新线程，在新的线程运行 run 方法中的代码。
start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次会出现IllegalThreadStateException。
run()
新线程启动后会调用的方法。
如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为。
getName()
获取线程名。
setName(String)
修改线程名
getState()
获取线程状态
isAlive()
线程是否存活（还没有运行完毕）
过时方法
这些方法已过时，容易破坏同步代码块，造成线程死锁，不推荐使用。
stop()
停止线程运行
suspend()
挂起（暂停）线程运行
resume()
恢复线程运行