勿以恶小而为之，勿以善小而不为--------------------------刘备
劝诸君，多行善事积福报，莫作恶
上一章简单介绍了 Thread和Runnable实现多线程(一),如果没有看过，请观看上一章
一. Thread 的静态优先级常量
一.一 静态常量
| 静态常量 | 值 |
|---|---|
| MAX_PRIORITY | 最大优先级,值为10 |
| MIN_PRIORITY | 最小优先级，值为1 |
| NORM_PRIORITY | 默认优先级，值为5 |
一. 二 演示 优先级常量
@Test
public void staticTest(){
System.out.println("max:"+Thread.MAX_PRIORITY);
System.out.println("norm:"+Thread.NORM_PRIORITY);
System.out.println("min:"+Thread.MIN_PRIORITY);
}
运行测试，查看控制台:
二. Thread 中方法
二.一 构造 方法
二.一.一 方法
| 方法 | 作用 |
|---|---|
| Thread() | 默认，线程的名称系统自定义 |
| Thread(String name) | 用户传入唯一的线程名称 |
| Thread(Runnable target) | 传入 runnable对象 |
| Thread(Runnable target, String name) | 传入runnable对象和唯一线程名称name |
二.一.二 演示构造方法
@Test
public void conTest(){
//空构造
Thread thread=new Thread();
//传入名称
Thread thread1=new Thread("自定义线程");
//传入Runnable
Thread thread2=new Thread(new MyRunnable());
//4 传入Runnable 和name
Thread thread3=new Thread(new MyRunnable(),"自定义Runnable接口");
}
二.二 其他方法
| 方法 | 作用 |
|---|---|
| static Thread currentThread() | 获取当前的运行线程 |
| void setName(String name) | 设置线程的名称，一般在线程运行之前设置 |
| String getName() | 获取线程的名称 |
| void setPriority(int newPriority) | 设置线程的优先级 |
| int getPriority() | 获取线程的优先级 |
| Thread.State getState() | 获取线程的状态 |
| boolean isAlive() | 判断线程是否还活着 |
| void setDaemon(boolean on) | 设置是否是守护线程，必须在未start 之前设置 |
| boolean isDaemon() | 是否是守护线程 |
| void interrupt() | 中断线程 |
| static boolean interrupted() | 线程是否已经中断 |
| boolean isInterrupted() | 是否被中断 |
| void join() | 让此线程获取资源，强制运行 |
| static void sleep(long millis) | 优眠， 单位是毫秒 |
| void start() | 开启 |
| static void yield() | 线程释放资源，不首先运行 |
三. 演示线程名称 getName()
@Test
public void nameTest() throws Exception{
NameThread nameThread=new NameThread();
Thread thread1=new Thread(nameThread);
//默认的为 Thread-接下来的数据， 从0开始。
Thread thread2=new Thread(nameThread,"自定义线程");
Thread thread3=new Thread(nameThread);
Thread thread4=new Thread(nameThread,"两个蝴蝶飞，你好");
thread1.start();
thread2.start();
thread3.start();
thread4.start();
// main, main方法也是一个线程
System.out.println("当前线程的名称:"+Thread.currentThread().getName());
}
class NameThread implements Runnable{
@Override
public void run() {
for(int i=0;i<5;i++){
System.out.println("当前线程:"+Thread.currentThread().getName()+"正在运行，输出:"+i);
}
}
}
运行程序，控制台打印输出
如果不传入线程的名称， 则线程的名称系统自分配为: Thread-不重复数字
四. 获取线程的信息
四.一 主线程状态
@Test
public void readMainTest() throws Exception{
//1. 获取当前的主线程
Thread thread=Thread.currentThread();
System.out.println("当前线程的名称:"+thread.getName());
System.out.println("获取标识符 id:"+thread.getId());
System.out.println("获取优先级:"+thread.getPriority());
System.out.println("获取状态:"+thread.getState());
System.out.println("当前线程是否还活着:"+thread.isAlive());
System.out.println("是否被中断:"+thread.isInterrupted());
System.out.println("是否是守护线程:"+thread.isDaemon());
//可以手动设置名称和优先级
thread.setName("手动设置名称");
thread.setPriority(Thread.MAX_PRIORITY);
System.out.println("当前线程的名称:"+thread.getName());
System.out.println("获取优先级:"+thread.getPriority());
//设置守护线程，必须要在线程运行之前进行设置
}
运行程序，看控制台输出:
四.二 Runnable 线程状态
@Test
public void readNoTest() throws Exception{
ReadRunnable readRunnable=new ReadRunnable();
Thread thread=new Thread(readRunnable);
thread.start();
}
class ReadRunnable implements Runnable{
@Override
public void run() {
Thread thread=Thread.currentThread();
System.out.println("当前线程的名称:"+thread.getName());
System.out.println("获取标识符 id:"+thread.getId());
System.out.println("获取优先级:"+thread.getPriority());
System.out.println("获取状态:"+thread.getState());
System.out.println("当前线程是否还活着:"+thread.isAlive());
System.out.println("是否被中断:"+thread.isInterrupted());
System.out.println("是否是守护线程:"+thread.isDaemon());
//可以手动设置名称和优先级
thread.setName("手动设置名称");
thread.setPriority(Thread.MAX_PRIORITY);
System.out.println("当前线程的名称:"+thread.getName());
System.out.println("获取优先级:"+thread.getPriority());
}
}
运行程序，控制台打印输出:
五. 守护线程 setDaemon()
守护线程指的就是， 即使 Main 线程结束了， 此线程仍然会继续运行。
五.一 设置守护线程
@Test
public void read3Test() throws Exception{
Read3Runnable readRunnable=new Read3Runnable();
Thread thread=new Thread(readRunnable);
System.out.println("判断是否启动:"+thread.isAlive());
System.out.println("是否是守护线程:"+thread.isDaemon());
//在开启之前设置
thread.setDaemon(true);
thread.start();
System.out.println("是否启动:"+thread.isAlive());
System.out.println("是否是守护线程:"+thread.isDaemon());
}
class Read3Runnable implements Runnable{
@Override
public void run() {
System.out.println("获取线程的名称:"+Thread.currentThread().getName());
}
}
运行程序，控制台打印输出:
五.二 守护线程
@Test
public void daemonTest() throws Exception{
DaemonRunnable daemonRunnable=new DaemonRunnable();
Thread thread=new Thread(daemonRunnable);
//先不是守护线程
//启动
// thread.setDaemon(true);
thread.start();
}
static class DaemonRunnable implements Runnable{
@Override
public void run() {
//死循环，会一直执行。
for(;;){
System.out.println("我扣");
}
}
}
此时运行, ，则运行一段时间之后，结束运行
如果将注释去掉，设置成守护线程的话，则会一直打印输出。
六. 线程的状态 State
线程的状态有以下几种:
- NEW 尚未启动的线程处于此状态。
- RUNNABLE 在Java虚拟机中执行的线程处于此状态。
- BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
- WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED 已退出的线程处于此状态。
@Test
public void readStateTest() throws Exception{
ReadStateRunnable readRunnable=new ReadStateRunnable();
Thread thread=new Thread(readRunnable);
Thread.State state=thread.getState();
System.out.println("开启前状态:"+state);
thread.start();
state=thread.getState();
System.out.println("开启后状态:"+state);
}
class ReadStateRunnable implements Runnable{
@Override
public void run() {
System.out.println("获取线程的名称:"+Thread.currentThread().getName());
}
}
运行程序，控制台打印输出:
七. 线程优眠 sleep
会暂停时间。
//线程的休眠
@Test
public void sleepTest(){
SleepRunnable readRunnable=new SleepRunnable();
Thread thread=new Thread(readRunnable);
thread.start();
//休眠5秒， 保证后面的先不执行。
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("休眠结束，运行成功");
}
class SleepRunnable implements Runnable{
@Override
public void run() {
try {
//暂时3秒后才输出内容。
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("输出线程名称:"+Thread.currentThread().getName());
}
}
八. 线程的强制执行 join()
让这个线程强制最先执行。
//线程的 join 方法
@Test
public void joinTest() throws Exception{
JoinRunnable joinRunnable=new JoinRunnable();
Thread thread=new Thread(joinRunnable);
//启动
thread.start();
// 主线程有10个，副线程100个，按理是 main先执行完， 加入了 join之后，强制让副线程先执行完。
for(int i=0;i<10;i++){
//让当前线程死掉.
if(i==8){
//当运行8后， 让 thread线程强制运行，即到 i=8了，不运行了，让 其他线程运行了。
// 保证 i=8,i=9 最后输出。
thread.join();
}
System.out.println("当前线程:"+Thread.currentThread().getName()+"运行到:"+i);
}
}
class JoinRunnable implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println("输出内容:"+Thread.currentThread().getName()+",运行到:"+i);
}
}
}
运行程序， 查看控制台输出:
九. 线程的暂时挂起，不执行 yield()
注意， yield() 方法，只是让此线程释放资源，不执行，但不能保证最后执行。 可以线程 i=8时，得到了资源， 然后判断了i>=7, 执行 .yield() 方法，释放资源， 忽然它又得到了资源， 那么i=8 就会运行了。 不像 join()那样强制。
@Test
public void yieldTest() throws Exception{
YieldRunnable yieldRunnable=new YieldRunnable();
Thread thread=new Thread(yieldRunnable);
//启动
thread.start();
for(int i=0;i<100;i++){
System.out.println("当前线程:"+Thread.currentThread().getName()+"运行到:"+i);
}
}
class YieldRunnable implements Runnable{
@Override
public void run() {
Thread thread=Thread.currentThread();
for(int i=0;i<10;i++){
if(i>=7){
//级别设置小点， 让其不执行。
thread.setPriority(Thread.MIN_PRIORITY);
Thread.yield();
}
System.out.println("输出内容:"+thread.getName()+",运行到:"+i);
}
}
}
运行程序，查看控制台输出
这儿的 i=7,i=8,i=9 就得到了资源，执行了，而不是强制最后执行。
十. 打断休眠 interrupt()
主要用于 打断 休眠。
@Test
public void interTest() throws Exception{
InterruptRunnable interruptRunnable=new InterruptRunnable();
Thread thread=new Thread(interruptRunnable);
//启动
thread.start();
//休眠两秒
Thread.sleep(2000);
//两秒之后，进行打断， 副线程应该还在休眠的状态上。
thread.interrupt();
Thread.sleep(5000);
}
class InterruptRunnable implements Runnable{
@Override
public void run() {
System.out.println("开始进行休眠");
try {
Thread.sleep(5000);
System.out.println("休眠结束");
} catch (InterruptedException e) {
System.out.println("休眠被打断");
}
System.out.println("退出休眠");
}
}
运行程序，
十.一 设置停止和重启
以前 是有 stop() 这样的方法的，后来被抛弃了， 用标志位进行设置关闭和启动。
class MyRunnableDemo implements Runnable{
private boolean isRun=true;
@Override
public void run() {
//定义此标识位
while(isRun){
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("打印输出");
}
}
//通过标识位进行相应的控制
public void stop(){
this.isRun=false;
}
public void restart(){
this.isRun=true;
run();
}
}
public class StopDemo {
public static void main(String[] args) {
MyRunnableDemo myRunnableDemo=new MyRunnableDemo();
Thread thread=new Thread(myRunnableDemo);
System.out.println("开始启动");
thread.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
myRunnableDemo.stop();
System.out.println("停止");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("重新启动");
myRunnableDemo.restart();
}
}
运行程序，查看控制台。
这就是 Thread 类的常用方法，必须要掌握使用。
谢谢您的观看，如果喜欢，请关注我，再次感谢 !!!
转载：https://blog.csdn.net/yjltx1234csdn/article/details/106859152
查看评论