多线程操作
多线程运行状态不确定，通过名称操作该线程
操作方法在Thread类中
public Thread (Runnable target, String name) 构造方法设置线程名 public final void setName (String name) 设置名字，不可修改 public final String getName () 取得名字 public static Thread currentThread () 获取线程 public static void sleep (long millis) throws InterruptedException 线程休眠 public static void sleep (long millis, int nanos) throws InterruptedException 线程休眠 public boolean isInterrupted () 判断线程是否被中断 public void interrupt () 中断操作执行 public final void join() throws InterruptedException 强制执行 public static void yield () 线程礼让 public final void setPriority (int newPriority) 设置线程优先级 public final int getPriority () 获取线程优先级
[toc]
设置线程名
class CustomThread implements Runnable{
@Override
public void run(){ }
}
public static void main(String[] args){
CustomThread thread = new CustomThread();
new Thread(thread, "custom-thread"); // 构造方法设置线程名
new Thread(thread); // 未设置线程名自动设置名字
}
获取线程名
获取当前线程信息，写在run()方法中，每次线程启动时由start()调用
class CustomThread implements Runnable{
@Override
public void run(){
Thread.currentThread().getName();
}
}
未起名会自动非重命名，使用static属性和方法自动编号
private static int threadInitNumber; private static synchronized int nextThreadNum() { return threadInitNumber++; }
public static void main(String[] args){
CustomThread thread = new CustomThread();
new Thread(thread, "custom-thread"); // 设置线程名
new Thread(thread); // 未设置线程名自动设置名字
}
主方法也是线程
在new子线程之后写main方法逻辑，主线程和子线程抢占资源并发执行
public static void main(String[] args){
CustomThread thread = new CustomThread();
new Thread(thread, "custom-thread").start();
thread.run(); // 执行CustomThread中覆写的run()方法
}
custom-thread
main //main()方法中直接调用线程类对象中的run()方法，线程名为main
执行java程序时启动一个JVM进程-java.exe。同时启动多个进程，每个JVM进程中会有各自的线程，进程中主方法是主线程，主线程创建若干子线程
主线程负责整体流程，子线程负责耗时逻辑
线程休眠
线程暂缓执行，休眠时长到后线程唤醒，继续进行后续处理
线程休眠可能被其他线程打断，抛出中断异常InterruptedException，为Exception子类，必须进行异常处理
new Thread(() -> {
try{
Thread.sleep(1000);
}catch(InterruptedException e){
// 中断处理
}
}), "线程名").start();
多个线程对象之间执行操作有先后顺序，多个线程休眠彼此之间仍有先后顺序
线程中断
所有正在执行的线程都可以被中断，中断线程强制进行异常处理
Thread thread = new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() + "线程开始休眠");
Thread.sleep(5000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "线程被中断");
}
}, "被动中断线程");
thread.start();
try {
thread.sleep(2000);
if (!thread.isInterrupted()) {
thread.interrupt();
System.out.println("中断成功");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
被动中断线程线程开始休眠
中断成功
被动中断线程线程被中断
线程强制执行
一个线程对象一直独占资源直到该线程程序执行结束
获取强制执行线程对象后，执行join方法的线程执行完毕后，其他线程才可以获得计算资源执行
Thread mainThread = Thread.currentThread();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
if (i == 3) {
try {
mainThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + i);
}
}, "被抢占资源线程").start();
for (int j = 0; j < 5; j++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(mainThread.getName() + j);
}
被抢占资源线程0
被抢占资源线程1
被抢占资源线程2
main0
main1
main2
main3
main4
被抢占资源线程3
被抢占资源线程4
线程礼让
暂时让出计算资源给相同或更高优先级线程，每次调用yeild()只礼让一次
Thread mainThread = Thread.currentThread();
new Thread(() -> {
for (int i = 0; i < 5; i++) {
if (i == 1) {
Thread.currentThread().yield();
System.out.println("i到" + i + "线程礼让一次");
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + i);
}
}, "礼让线程").start();
for (int j = 0; j < 5; j++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(mainThread.getName() + j);
}
main0
礼让线程0
i到1线程礼让一次
main1
礼让线程1
main2
礼让线程2
main3
礼让线程3
main4
礼让线程4
线程优先级
优先级高先执行概率更大
public static final int MAX_PRIORITY 最高优先级 10 public static final int NORM_PRIORITY 中等优先级 5 public static final int MIN_PRIORITY 最低优先级 1
主线程和线程默认是中等优先级，主线程和子线程并发执行