黑马程序员：Java基础——多线程的停止与守护以及Join，优先级和yield方法

最新推荐文章于 2023-08-13 15:26:53 发布
最新推荐文章于 2023-08-13 15:26:53 发布
阅读量450 收藏 1
点赞数
分类专栏： 黑马入学Blog 文章标签： 黑马训练营 多线程 停止进程 守护进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a13366325930/article/details/40016435
版权
------- Java EE培训、 java培训、期待与您交流！ ----------

1.概念

线程启动了，做完该做的事情，但是它还是会占用系统资源，那么我们该如何停止呢？

我们知道Java中Thread里面有一个方法叫做stop方法，可是，stop方法已经过时。

那么，如何停止线程？只有一种，run方法结束。

开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。

我们先来举个例子：

class StopThread implements Runnable{
	private Boolean flag = true;
	public void run(){
		while(flag){
			System.out.println(Thread.currentThread().getName()+"---run");
		}
	}
	public void changeFlag(){
		flag = false;
	}
}

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread sThread = new StopThread();

        new Thread(sThread).start();
        new Thread(sThread).start();
        
        int num = 0;
        while(true){
        	if(num++ == 60){
        		sThread.changeFlag();
        		break;
        	}
        	System.out.println(Thread.currentThread().getName()+"++++++"+num);
        }
        System.out.println("Over");
    }
}

我们来看一下运行结果：


只见这哥们一顿运行，到了num==60的时候程序调用了changeFlag()结束了所有线程。

有一种特殊情况，这种情况程序停不下来，那就是使用了synchronized的同步锁。

我们先来看一下代码：

class StopThread implements Runnable{
	private Boolean flag = true;
	public synchronized void run(){
		while(flag){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
				System.out.println(Thread.currentThread().getName()+"...Exception");
			}
			System.out.println(Thread.currentThread().getName()+"---run");
		}
	}
	public void changeFlag(){
		flag = false;
	}
}

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread sThread = new StopThread();

        new Thread(sThread).start();
        new Thread(sThread).start();
        
        int num = 0;
        while(true){
        	if(num++ == 60){
        		sThread.changeFlag();
        		break;
        	}
        	System.out.println(Thread.currentThread().getName()+"++++++"+num);
        }
        System.out.println("Over");
    }
}

接下来，我们来运行一下：


可以看到，我们的程序只有main线程在输出，而其他两个线程则没有动静，而且，注意图的右上角，红色的小方块证明了这个程序还没有结束。这是为什么呢？

我们回顾一下代码：

我们的flag默认为true，当线程进入synchronized同步锁中判断flag就会直接被位于上面的wait()方法直接叫停，也就是进入冻结状态，同时释放了CPU运行权。这是另一个线程也来了，同样被wait()方法叫停。这两个方法一旦被叫停就无法读取到位于wait()下面的标记，也就无法终止线程了。

我们这样总结：

当线程处于冻结状态时就不会读取到标记，那么线程就不会结束。

那么该如何解决这个问题呢？

在Java的Thread中提供了一种中断线程的方法——interrupt，需要注意的是这个中断不是停止线程，能停止线程的只有stop方法。

* 如果线程在调用Object 类的wait()、wait(long) 或wait(long, int) 方法，或者该类的join()、join(long)、join(long, int)、sleep(long) 或sleep(long, int) 方法过程中受阻，则其中断状态将被清除

interrupt方法的意思就是强制清除线程的冻结状态，即强制唤醒。但是会将收到一个InterruptedException异常。

我们来修改一下代码：

class StopThread implements Runnable{
	private Boolean flag = true;
	public synchronized void run(){
		while(flag){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
				System.out.println(Thread.currentThread().getName()+"...Exception");
			}
			System.out.println(Thread.currentThread().getName()+"---run");
		}
	}
	public void changeFlag(){
		flag = false;
	}
}

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread sThread = new StopThread();

        Thread t1 = new Thread(sThread);
        t1.start();
        new Thread(sThread).start();
        
        int num = 0;
        while(true){
        	if(num++ == 60){
        		//sThread.changeFlag();
        		t1.interrupt();
        		break;
        	}
        	System.out.println(Thread.currentThread().getName()+"++++++"+num);
        }
        System.out.println("Over");
    }
}

然后我们运行一下：


注意图中，线程没有终止，而且接收到了异常。为什么没有终止？因为t1被强制唤醒以后又去争CPU执行权时，经过wait()方法时，又一次冻结在那里。同理，另一条线程也这样修改。

这时，我们离结束线程不远了，只要发生了异常我们不妨操作标记来结束线程：

class StopThread implements Runnable{
	private Boolean flag = true;
	public synchronized void run(){
		while(flag){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
				System.out.println(Thread.currentThread().getName()+"...Exception");
				flag = false;
			}
			System.out.println(Thread.currentThread().getName()+"---run");
		}
	}
	public void changeFlag(){
		flag = false;
	}
}

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread sThread = new StopThread();

        Thread t1 = new Thread(sThread);
        t1.start();
        Thread t2 = new Thread(sThread);
        t2.start();
        
        int num = 0;
        while(true){
        	if(num++ == 60){
        		//sThread.changeFlag();
        		t1.interrupt();
        		t2.interrupt();
        		break;
        	}
        	System.out.println(Thread.currentThread().getName()+"++++++"+num);
        }
        System.out.println("Over");
    }
}
运行结果如下：

我们可以看到，线程异常一样是被输出，但是注意右上角，小方块呈灰色，证明此时程序已经停止运行，也就是说，我们已经将t1,t2两个线程成功的终止掉了。

2.守护线程

Java中提供了一种方法——setDaemon()

setDaemon()将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。

守护线程可以理解为后台线程。

该方法必须在启动线程前调用。

该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。

接下来我们看一下示例：

class DaemonThread implements Runnable {
	private Boolean flag = true;

	public void run() {
		while (flag) {
			System.out.println(Thread.currentThread().getName() + "---run");
		}
	}

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

public class DaemonDemo {
	public static void main(String[] args) {
		StopThread sThread = new StopThread();

		Thread t1 = new Thread(sThread);
		Thread t2 = new Thread(sThread);

		t1.setDaemon(true);
		t2.setDaemon(true);
		t1.start();
		t2.start();

		int num = 0;
		while (true) {
			if (num++ == 60) {
				break;
			}
			System.out.println(Thread.currentThread().getName() + "++++++" + num);
		}
		System.out.println("Over");
	}
}

运行结果是main方法做完了应有的工作，而此时程序关闭。

3.Join()方法

前面Interrupt()方法中我们见到过join()方法，join()是什么呢？

接下来我们来看一下join()方法：

在JDK中是这么说的：等待该线程终止。

我们不妨先来看段代码：

class Join implements Runnable{
	public void run(){
		for(int i = 0;i<70;i++){
			System.out.println(Thread.currentThread().getName()+"---"+i);
		}
	}
}

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
		Join j = new Join();
		Thread t1 = new Thread(j);
		Thread t2 = new Thread(j);

		t1.start();
		t1.join();     //join是抢夺CPU执行权
		t2.start();
		
		for(int i=0;i<80;i++){
			System.out.println("main______"+i);
		}
		System.out.println("Over!!!");
	}
}

运行结果：通常情况下，我们的t1,t2,main线程都是交叉运行，输出结果的。但是，当我们添加join()方法后，如上面的代码，这个程序输出的顺序就会是这样的：

1.先让t1全部执行完。

2.再让t2和main线程交替运行。

3.执行完毕，最后关闭程序。

我们就可以理解了，join()方法是一个让本线程执行完，再让其他线程执行的方法。

可是接下来我们这样改：

t1.start();
t2.start();
t1.join();
我把join()放到了t2.start()后面去，执行结果如下：

这又是怎么回事呢？

当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。

join可以用来临时加入线程执行。

但是当A线程启动，B线程也会启动，但是当主线程碰到A线程的join方法时，主线程就会进入等待状态，而此时A，B线程都在运行状态，那么这时A，B线程就会交替执行，执行完后主线程就会执行。但是，此时的A，B线程并没有消亡，而是处于挂起状态，当主线程执行完毕后才会一起结束，此时，程序结束。


4.优先级&yield方法

        优先级代表抢资源的频率。

     优先级有10级

     其中1,5,10级为最明显。


static int

MAX_PRIORITY
       线程可以具有的最高优先级。

static int

MIN_PRIORITY
       线程可以具有的最低优先级。

static int

NORM_PRIORITY
       分配给线程的默认优先级。

加蓬丝蝰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈java多线程 join方法以及优先级方法
08-31
本文将深入探讨Java中的`join()`方法以及线程的优先级概念。 首先，我们来看`join()`方法。`join()`方法用于线程同步，当一个线程（例如线程A）调用另一个线程（例如线程B）的`join()`方法时，线程A会暂停执行，...
Java线程中yield与join方法的区别Java开发J
11-25
在Java多线程编程中，理解并正确使用`yield`和`join`方法是至关重要的。这两个方法都属于线程控制策略的一部分，但它们的作用和使用场景有所不同。 首先，我们来详细探讨`Thread.yield()`方法。这个方法的目的是让...
黑马程序员_Java基础_线程间通信,生产者消费者案例,jdk1.5锁机制,守护线程
黑马程序员_ord
05-20 566
一，线程间的通信 1，在线程中我们使用多线程进行操作的时候，都是对同一个资源进行相同的操作。如果我们想要通过多线程操作某一个资源但是操作的动作都不相同的时候，这时候就会有两个run方法。那么这两个run方法就代表不同的动作，也就是有不同的线程，那么怎样让着两个线程之间的同步是安全的呢？方法当然是加锁。 我们先来看这个程序的需求：一个人在往系统中输入一个人的姓名和性别，另一个人在
Java多线程六：线程优先级和yield()让步函数
小鱼儿的专栏
10-24 4041
可以看出,不管优先级和yield()函数都是试图控制线程的顺序执行.但是我们需要注意的一点是,在java中没有任何机制可以保证线程的执行顺序,两种做法只不过是增加了线程之间切换的几率而已.，
Java多线程复习：5（sleep、yield方法和线程优先级）
小关同学的博客
04-22 153
start、yield方法和线程优先级 start方法 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）； 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException； 睡眠结束后的线程未必会立刻得到执行，还得看任务调度器的心情； 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性； 我们下面会用三个例子来说明上面的几点。 例一： imp
小知识点 yield、join、sleep和wait
happy_85的专栏
02-08 209
yield()方法使用示例 在下面的示例程序中，我随意的创建了名为生产者和消费者的两个线程。生产者设定为最小优先级，消费者设定为最高优先级。在Thread.yield()注释和非注释的情况下我将分别运行该程序。没有调用yield()方法时，虽然输出有时改变，但是通常消费者行先打印出来，然后事生产者。 join()方法 线程实例的方法join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行 slee..
Java多线程（2）——线程状态，操作，优先级
wayblink的博客
01-12 613
线程生命周期线程具有生命周期，其中包括5种状态：New，Runnable，Running，Blocked，Dead1、新建状态（New）：新创建了一个线程对象，在使用start()方法之前线程都处于新建状态或者叫出生状态。2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。3、运行状态（Run
Java线程中yield与join方法的区别
12-22
之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 　Java线程调度...
Java多线程-Thread类的常用结构及线程优先级
最新发布
01-27
Java多线程编程是开发高并发应用的基础，其中Thread类是实现多线程的核心类。本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称...
Java多线程yield心得分享
09-04
Java多线程编程是开发高并发应用的关键技术之一，其中`Thread.yield()`方法是一个重要的概念，用于线程之间的协作。这个方法允许当前正在执行的线程暂停执行，将其从运行状态变为可执行状态，从而可能让其他线程有...
JAVA中的多线程(八)：线程的优先级和yield方法
weixin_34309543的博客
06-23 350
JAVA中的多线程(八)：线程的优先级和yield方法 优先级代表着抢资源的频率 所有线程默认优先级是5 yield()临时释放线程的执行权 1 class Demo implements Runnable 2 { 3 public void run() 4 { 5 for(int...
Java的优先级常见理解错误
HUANGZIJIU的博客
09-15 146
经验认为，Java的优先级不跟数学中的优先级一样，不会因为某条语句中的优先级的不同就按照优先级的顺序执行。比如: int i=1,j=1,c,d; c=(i+1)*i++; d=j++*(j+1); 结果是 c=2,d=3; 如果在数学中，肯定是先算（），然后再算乘除等其他的。 当然数学中也不存在i++，不过，总之Java的优先级的机制跟数学中的不太一样。 个人理解是，Java程序在运行的...
Java线程调度以及算法
weixin_62458944的博客
08-13 338
Java的线程调度程序是JVM的一部分，它决定应该运行哪个线程。无法保证线程调度程序将选择运行哪个可运行线程。一次只能有一个线程在一个进程中运行。线程调度程序主要使用抢占式或时间切片调度来调度线程。在抢占式调度下，优先级最高的任务一直执行，直到它进入等待或死亡状态或更高优先级的任务出现。在时间切片下，任务执行预定义的一段时间，然后重新进入就绪任务池。然后，调度程序根据优先级和其他因素确定接下来应执行的任务。
【Java】yield()和join()区别
qq_44544908的博客
02-19 608
1、yield的是静态方法也是native方法2、yield告诉正在执行的线程给线程池中有相同优先级的线程一个机会3、yield不能保证正在执行的线程立刻变成Runnable状态4、它仅仅可以使一个线程从running状态变成Runnable状态，而不是wait或者blocked状态。
Java多线程基础：Thread.yield()方法介绍
学亮编程手记
06-04 2297
当线程执行到数字 3 时，调用。方法是一个静态方法，用于提醒调度器当前线程愿意放弃 CPU 资源，让其他具有相同或更高优先级的线程有机会执行。方法并不会将当前线程阻塞，它只是让出一部分执行时间给其他线程，因此当前线程仍然处于可运行状态，可能会继续执行。方法的作用是告诉调度器当前线程的执行优先级较低，可以暂时让其他优先级较高的线程先执行。方法并不保证当前线程会立即停止执行，而只是表示当前线程愿意让出一部分执行时间。方法的效果依赖于操作系统和 JVM 的实现，不同的平台可能会有不同的行为。
java多线程-优先级&yield方法
深情小建
07-31 606
class Demo implements Runnable { public void run() { for(int x =0;x<70;x++) { System.out.println(Thread.currentThread().toString()+"....."+x); Thread.yi
学习——Java多线程编程（简要概括）
qq_52141922的博客
03-19 1153
1.多线程技能 1.什么是线程？在进程中独立运行的子任务。 2.多线程优点？可以大幅利用CPU的空闲时间来处理其他任务。 3.什么场景使用多线程？ 1.阻塞 2.依赖。 注： 1.多线程是异步的。线程被调用时机是随机的。 2.多次调用start()方法，则出现异常Exception in thread"main"java.lang.IllegalThreadStateException. 1.使用多线程 1.继承Thread类 2.实现Runnable接口 start()方法耗时的原因？ 1）通过JVM
调用线程的yield()方法会不会只让优先级相同的执行？
u011381576的博客
04-26 5131
     在一些blog上面，对于线程的yield(),他们对调用这个方法的的描述为，只会将运行权让给相同优先级或更高的优先级执行。这样就很容易使读者以为，如果有两个线程a和b，a的优先级大于b的优先级，即使a调用了yeild()方法，由于b的优先权低于a，那么线程需要等a运行完之后b才有机会运行，是这样的？public class YieldTest extends Thread { ...
java线程类：yield()方法详解！
zhaoliubao1的博客
10-09 2793
1.yield()定义： yield()方法的作用是放弃当前的cpu的资源，将他让给其他的任务去占用cpu执行时间。 但是放弃的时间不确定，有可能刚刚放弃又马上获得cpu时间片。《java多线程编程核心技术》 2.如何更好理解yield()? yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值