多线程的使用

1、线程的常用方法

1.1、Thread.sleep(毫秒数),让线程休眠,时间一到，自动唤醒并继续执行 。        例如下图：

Thread thread = new Thread(() -> {
    try {
        System.out.println("线程开始休眠");
        Thread.sleep(2000); 
        System.out.println("线程休眠结束");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
thread.start();

在暂停期间，线程不会占用 CPU 资源，但会保持对锁的持有（如果线程持有锁）。该方法可能会抛出InterruptedException异常，需要在调用时进行处理。

 Thread thread = new Thread())->{

                //方法体...

});

这是lambda表达式，支持方法引用，这是一种更简洁的调用已有方法的方式，可以进一步简化代码。更适用于简单的函数式行为表示，如集合的遍历操作（使用forEach方法）、函数式接口的实例化等场景，能够以简洁的方式表达单一的行为逻辑，使代码更加简洁明了。

1.2、Thread.currentThread():表示获取当前正在执行的线程对象

Thread thread = new Thread(() -> {
    System.out.println("当前线程：" + Thread.currentThread());
});
thread.start();
System.out.println("主线程：" + Thread.currentThread());

在多线程编程中，可以通过Thread.currentThread()获取当前线程的引用，然后获取线程的相关信息或进行一些与当前线程相关的操作。

1.3、public finalboolean isAlive(); 测试线程是否处于活动状态。活动状态包括线程已经启动但尚未终止，即线程的start()方法已经被调用且run()方法尚未执行完毕或者正在执行 。       例如下图：

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

thread.start();
System.out.println("线程是否存活：" + thread.isAlive()); 
try {
    thread.join();
    System.out.println("线程是否存活：" + thread.isAlive()); 
} catch (InterruptedException e) {
    e.printStackTrace();
}

1.4、getName()、setName():setName(String s)于设置线程的名称用于获取线程的名称。线程名称有助于在多线程编程中区分不同的线程，方便调试和日志记录。

优先级：可以给线程设置优先级，范围是1-10，10优先级最高。

1.5、setPriority(数字)：给线程设置优先级，这里优先级高，并不代表一定先执行，只是增加了抢占到资源的机会

1.6、getPriority():获取线程的优先级

Thread提供了三个优先级常量：

        Thread.MAT_PRIORITY=10

        NORM_PRIORITY = 5

        MIN_PRIORITY = 1                 Main方法的优先级，是5

1.7、join():当前线程暂停执行，新加入的线程开始执行，当新线程执行完之后，再执行当前线程

Thread thread = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("子线程执行中：" + i);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

thread.start();
try {
    thread.join(); 
    System.out.println("子线程执行完毕，主线程继续执行");
} catch (InterruptedException e) {
    e.printStackTrace();
}

 例如，在主线程中调用某个子线程的join()方法，主线程会被阻塞，直到该子线程执行完毕后主线程才会继续执行。该方法可以指定等待的最长时间（毫秒），如果超过该时间，主线程会继续执行。

1.8、 yeild();当前线程暂停执行,与其他线程同时抢占资源,如果还是自己抢占到,则继续执行后续的代码,如果是其他线程抢占到,则其他线程先执行.        yeild()方法使用方式如下图：

Thread thread1 = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("线程1执行中：" + i);
        if (i == 2) {
            Thread.yield(); 
        }
    }
});

Thread thread2 = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("线程2执行中：" + i);
    }
});

thread1.start();
thread2.start();

 2、线程的终止

2.1、方法一：

通过给定属性，通过控制属性值来破坏继续执行的条件。       

代码如下：

public class MyRun implements Runnable {

	private boolean flag = true;

	@Override
	public void run() {
		int i = 0;
		while (flag) {
			System.out.println("执行线程_" + i);
			i++;
		}
	}

	public void changeFlag() {
		flag = false;
	}
}

测试代码如下：

public class Test {

	public static void main(String[] args) {
		MyRun mr = new MyRun();
		new Thread(mr).start();


		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		mr.changeFlag();
	}
}

通过给定的睡眠时间，来控制属性值破坏while()死循环，在2000ms后运行mr.changeFlag()，将flag值改为false，从而结束运行

2.2、方法二：

使用interrupt() 方法结合线程的中断状态判断

1）interrupt（）是给线程设置中断标志；2）interrupted（）是检测中断并清理中断状态；3）isInterrupted（）只检测中断。还有重要的⼀点就是interrupted（）作⽤于当前线程，interrupt（）和isInterrupted（）作⽤于此线程，即代码中调⽤此⽅法的线程。

public class ThreadInterruptionExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在执行...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // 当线程在休眠时被中断，会抛出InterruptedException异常，同时清除中断标志位
                    System.out.println("线程被中断，执行中断处理逻辑");
                    Thread.currentThread().interrupt(); 
                }
            }
            System.out.println("线程终止");
        });

        thread.start();

        try {
            Thread.sleep(3000);
            thread.interrupt(); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，线程在循环中通过isInterrupted（）方法检查中断状态。当主线程调用thread.interrupt()中断子线程时，如果子线程正在休眠（sleep（）方法），会抛出 异常，在异常处理中重新设置中断标志位（因为抛出异常会清除中断标志位），然后线程可以根据中断标志位决定是否结束执行。

2.3、方法三：

如果线程因为执行join(),sleep()或是wait()而进入了阻塞状态，此时要想停止它，可以让它调用interrupt()，程序会抛出InterruptedException异常而被catch()子句捕获,进行处理

代码如下：

public class MyRun3 implements Runnable {

	@Override
	public void run() {
		int i = 0;
		while(true){
			System.out.println("线程_"+i);
			i++;
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				break;
			}
		}
	}

}

测试代码如下：

public class Test3 {

	public static void main(String[] args) {
		MyRun3 mr = new MyRun3();
		Thread th = new Thread(mr);
		th.start();


		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		//当调用interrupt方法时，可以改变interrupted的值
		//当th线程中有处理InterruptedException异常的时候，如果该线程调用了interrupt方法，那么该线程会抛出InterruptedException异常
		th.interrupt();
	}
}