影响线程执行的函数（sleep，join，yield，priority，daemon）

最新推荐文章于 2023-09-18 15:22:09 发布
最新推荐文章于 2023-09-18 15:22:09 发布
阅读量463 收藏
点赞数
分类专栏： java并发学习 文章标签： sleep join yield priority daemon
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010126792/article/details/99412928
版权

1 sleep

在这里插入图片描述
sleep使当前线程睡眠指定的毫秒数（暂停执行），但由于系统计时器和调度方法的影响，时间不是那么精准。当线程在同步代码中持有monitor时，sleep不会导致线程释放已经获取的锁（虽然当前线程暂停了，但其他竞争线程依然无法获取锁）。会抛出线程中断异常，必须处理。到达指定之间之后，线程会自动苏醒，变为可运行状态而不是运行状态，所以sleep内的时间是线程休眠的最短时间。
在这里插入图片描述
sleep的重载函数，暂停线程精确到纳秒，其实内部还是以毫秒进行处理。
源码：

//sleep 重载函数
public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        sleep(millis);
    }

public class Demo7 {

	public static void main(String[] args) {

		System.out.println("slee before: "+System.currentTimeMillis());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("slee afeter: "+System.currentTimeMillis());
	}

}

result：
slee before: 1565664285270
slee afeter: 1565664288271

2 join

在这里插入图片描述
join的用法是在一个线程A中调用另一个线程B的join，线程A在线程B执行完之前会一直阻塞在join方法的位置，这样就可以控制线程的执行顺序。

public class Demo7 {

	public static void main(String[] args) {
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
			System.out.println("线程1 sleep 之前 "+System.currentTimeMillis());
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println("线程1 sleep 之后"+System.currentTimeMillis());
			}
		});
		
        Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
			System.out.println("线程2，join之前 "+System.currentTimeMillis());
			try {
				thread1.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("线程2，join之后 "+System.currentTimeMillis());
				
			}
		});
        
        thread1.start();
        thread2.start();
	}

}

//运行结果，线程2的join之后这句话一定在线程1执行完之后。
线程1 sleep 之前 1565664869820
线程2，join之前 1565664869820
线程1 sleep 之后1565664870821
线程2，join之后 1565664870821

线程2，join之前 1565664952598
线程1 sleep 之前 1565664952598
线程1 sleep 之后1565664953599
线程2，join之后 1565664953599

join的重载函数
在这里插入图片描述
等待millis毫秒后，如果等待的线程依然没有执行完，就唤醒当前等待线程。

Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
			System.out.println("线程1 sleep 之前 "+System.currentTimeMillis());
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println("线程1 sleep 之后"+System.currentTimeMillis());
			}
		});
		
        Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
			System.out.println("线程2，join之前 "+System.currentTimeMillis());
			try {
				thread1.join(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("线程2，join之后 "+System.currentTimeMillis());
				
			}
		});
        
        thread1.start();
        thread2.start();

实现原理，内部利用wait实现：

 public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

3 yield

yield线程让步，线程调用了yield后，当前线程由“运行状态”进入到“就绪状态”，从而让自己或者其他线程获取执行权；但并不能保证其它线程一定能获得执行权；也有可能当前线程继续运行！（让出的是下一个时间片）
在这里插入图片描述

public class Demo7 {

	public static void main(String[] args) {
		
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
		
			int count =1000;
			while (count > 0) {
				count = count -1;
			}
			
			System.out.println("线程1  "+System.currentTimeMillis());
			}
		});
		
        Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
		
			int count =1000;
			while (count > 0) {
				count = count -1;
			}
			
			System.out.println("线程2 "+System.currentTimeMillis());
			}
		});
        
        thread1.start();
        thread2.start();
        thread1.yield();
	}

}

结果显示，线程1和线程2谁先执行的情况都有发生。

thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(Thread.MIN_PRIORITY);
thread1.start();
thread2.start();
thread1.yield();
添加了优先级之后依然 两种情况都存在。

4 优先级

Every thread has a priority. Threads with higher priority are executed in preference to threads with lower priority. Each thread may or may not also be marked as a daemon. When code running in some thread creates a new Thread object, the new thread has its priority initially set equal to the priority of the creating thread, and is a daemon thread if and only if the creating thread is a daemon.

java中每个线程都有一个优先级，开发者可以改变优先级，必须在执行之前设置优先级，优先级高的线程比优先级低的更易于被执行。 Java 虚拟机和下层的操作系统之间的约定是操作系统必须选择有最高优先权的 Java 线程运行。一个高优先级的线程到来时，无论低优先级的线程是否在运行，都会中断(抢占)它。但操作系统有时可能会选择一个更低优先级的线程运行，所以高优先级线程不一定优先执行，最终由由调度程序决定哪一个线程被执行。

当线程的优先级没有指定时，所有线程都携带普通优先级，其中10 表示最高优先级，1 表示最低优先级，5 是普通优先级， MIN_PRIORITY，MAX_PRIORITY，NORM_PRIORITY 。

public static void main(String[] args) {
		
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
			System.out.println("线程1  "+System.currentTimeMillis());
			}
		});
		
        Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
			System.out.println("线程2 "+System.currentTimeMillis());
			}
		});
        
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread2.setPriority(Thread.MIN_PRIORITY);
        thread2.start();
        thread1.start();
	}

运行结果，各种情况都存在。

5 守护线程

在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。

守护线程指当程序运行时在后台提供服务的线程，不是程序中不可获取的部分，守护线程起到辅助作用，没有它也可以，有了它可以为线程提供帮助，它提供的帮助你也可以不管（类似GC，文档的拼写检查）。守护线程为用户线程提供服务，当所有的非守护线程结束时，程序也就终止了虚拟机也就退出了。典型守护线程，垃圾收集器（GC）。
通过调用Thread对象的setDaemon(true)方法来设置守护线程（必须在线程start之前），不要再守护线程中做有关业务的逻辑操作（读取文件，数据库），因为守护线程可能随时发出中断，即使在程序执行过程中（用户线程执行完毕，VM会终止，此时可能守护线程还没执行完）。

public class Demo7 {

	public static void main(String[] args) {
		
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println("线程1  "+System.currentTimeMillis());
			}
		});
		
        Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			System.out.println("线程2 "+System.currentTimeMillis());
			}
		});
        
        thread2.setDaemon(true);
        thread2.start();
        thread1.start();
	}

}

线程2中syste.out的语句不会执行。

lidongxiu0714
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程之sleep带来的困惑
qq_35409525的博客
06-06 5107
  以前对多线程这一块了解的很少，经历过这几个月的春招备战，面试后，感觉多线程这一块是很多面试官经常问的，可以说对于我们来说这一块也是重中之重呀。其实当你接触了他以后，感觉多线程这个东西还是挺有意思的。所以接下来我就把我所知道 的了解的东西分享给大家，希望对大家有所帮助。  sleep()方法在多线程中也是经常用到的一个方法。sleep()方法的作用是让当前正在执行的线程进入休眠（暂停执行）。请看...
JAVA 线程中启动线程
01-15
- **yield()**：让当前线程暂停，给其他可运行线程一个执行机会，但不保证一定能切换。 - **interrupt()**：中断线程，标记线程的中断状态，对于阻塞操作（如sleep、wait）会抛出`InterruptedException`。 4. **...
多线程_yield()方法
最新发布
滨海之君的博客
09-18 911
方法是Java中Thread类的一个静态方法，它的作用是提示线程调度器当前线程愿意让出自己的CPU时间片，将CPU资源让给其他具有相同或更高优先级的线程。这意味着，如果线程持有某个锁，它仍然会保持这个锁，其他线程仍然无法获得这个锁。方法是一种线程协作的手段，它可以用来提示线程调度器，但不能保证线程会立即让出CPU执行权。方法不是强制性的线程调度控制，而是一种对线程调度器的提示。线程可以选择遵循这个提示，也可以忽略它。方法不能确保当前线程会立即让出CPU执行权，但它会增加其他线程获得CPU执行权的机会。
第09章_线程Join_Yield_Priority
e2603199的博客
05-28 104
Join 合并线程public class Test20180528{ public static void main(String args[]){ My s = new My();                                \\new一个新的并行线程对象 s.start();                                                ...
第九章 Java多线程机制 03_Join_Yield_Priority
jinhongliang123的专栏
09-02 659
鱼欲遇雨：每日都学习一点，持之以恒，天道酬勤！不能用电脑时，提前补上！（2012.9.2） join方法 合并某个线程 // TestJoin.java public class TestPriority { public static void main(String args[]) { Thread t1 = new Thread(new T1()); Thread
多线程 sleep,yield,join
lxwfly的博客
04-22 160
jdk 中yield方法注释翻译： 提示调度程序当前线程愿意放弃当前对处理器的使用。调度程序可以忽略这个提示。 Yield是一种启发式尝试，旨在改善线程之间的相对进展，否则线程将过度使用CPU。它的使用应该与详细的分析和基准测试结合起来，以确保它实际上具有预期的效果。 很少使用这种方法。对于调试或测试目的，它可能会很有用，因为它可以帮助再现由于竞争条件而产生的bug。在设计诸如{@link java.util.concurrent中的并发控制结构时，它可能也很有用。锁}包 yield: 在多个线程执
java多线程Demo
03-29
但是，线程优先级并不保证绝对的执行顺序，操作系统调度策略可能影响实际执行顺序。 7. join()方法： 一个线程调用另一个线程的join()方法，会等待该线程执行完毕后再继续执行，可以用来控制线程的执行顺序。 8. ...
Thread 线程 java编程 亲手测试了的
12-22
1. **join()**：让当前线程等待指定线程结束，调用`join()`方法的线程会暂停执行，直到目标线程完成其任务。 2. **sleep()**：使当前线程暂停指定毫秒数，然后继续执行。 3. **yield()**：让当前线程放弃CPU执行权...
关于Java的基础线程部分
04-28
- **join()**：等待该线程结束，即当前线程等待调用join()的线程执行完毕后再继续。 - **yield()**：让当前线程暂停，但不会进入阻塞状态，而是重回就绪状态，可能立刻再次获得CPU执行权。 - **interrupt()**：...
Java 语法总结——线程(线程)
04-13
6. 线程join()：让当前线程等待指定线程执行完毕后再继续执行。 五、线程优先级 Java提供10级线程优先级，通过setPriority(int priority)设置。优先级高的线程更容易获得CPU执行时间，但并不保证。优先级范围是MIN_...
线程控制sleep、join、daemon
he0707的博客
05-29 70
sleep package myMultithreadingDemo; public class ThreadSleep extends Thread { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName() + ": " + i); try { //publi
Java 线程sleep()，join（），yield（）方法
Mying的博客
06-30 333
Java 线程sleep()，join()方法 sleep()方法是让线程“睡眠”（即停下来等待）所指定的一段时间，在睡眠结束后，线程立即恢复执行，参与竞争运行资源。参数long millis指定毫秒数，int nanos指定纳秒数。 线程mThread1打印数字每打印一个数字休眠1s，mThread2打印字母每次休眠500ms package teach; class mThread1 ex...
Day24（ObjectString,MyThread,Properties,ThreadDaemon,ThreadJoin,ThreadPriority,ThreadSleepThreadStop）
weixin_65996579的博客
02-23 75
ObjectString,MyThread,Properties,ThreadDaemon,ThreadJoin,ThreadPriority,ThreadSleep,ThreadStop,ThreadYield,MyRunnable,SellTicket
c++11 yield函数的使用
neuzhangno的博客
03-02 1333
yield
线程join、yield、priority、daemon方法
cuixuange的博客
04-14 419
线程、进程运行的五个状态：创建、就绪、运行、阻塞、中止。它们之间的关系的非常重要，是这几个方法的理论基础。 join方法： 例如main线程中调用thread-0.join()方法。或者join(long mills) result: 将main线程由运行态进入阻塞态，等待thread-0的执行完成或者一段时间后，重新进入就绪状态。 public class ThreadJoin extend
java thread sleep 效率_Java多线程-线程的调度(休眠)
weixin_42382748的博客
02-16 403
Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。这里要明确的一点，不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。线程休眠的目的是使线程让出CPU的最简单的做法之一，线程休眠时候，会将CPU资源交给其他线程，以便能轮换执行，当休眠一定时间后，线程会苏醒，进入准备状态等待执行。线程休眠的方法是Thread.sleep(...
导致线程状态转换的方法（线程调度）（sleep(),wait(),join(),yeild(),await(),signal区别）
石头的博客
09-15 446
这里写自定义目录标题导致线程状态转换的方法（线程调度）Thread.sleep()锁对象.wait()方法Thread对象.join()Thread.yield()await()和signal 导致线程状态转换的方法（线程调度） sleep(),wait(),join(),yeild(),await(),signal()的区别 Thread.sleep() sleep()方法导致了程序暂停执行指定的时间，让出 cpu 给其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复到运行状态。在调用 s
多线程中的join(),yield()与优先级Priority
醉看梦晨馨
03-22 1257
1、join()：join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。 ublic class Test { public static void main(String[] args) { MyThread2 m2 = new MyThread2("asda"); m2.start(); try {
Linux C++使用重载函数作为线程函数的方法
jinking01的专栏
10-29 373
一般来说，如果一个类内有2个同名不同参数的方法，比如run(int a, int b)和run(string a, int b)，那么如果想使用其中一个作为线程方法来创建线程，常规方法是不能成功的，会报出找不到该方法的错误。 我们在前面做传感器管理时，传感器插件基类PluginBase中有一个dataProcess(int , std::map)方法。该方法是一个线程函数，我们在PluginManager类中将它作为线程函数，为每个插件创建一个线程。但是后面因为大部分插件的...
线程join、yield、sleep
09-02
线程是指程序执行的流程，而线程操作是指对线程进行控制和管理的操作。其中，线程join、yield和sleep是常用的线程操作。 线程join是指让一个线程等待另一个线程执行完毕后再继续执行。通过调用join方法，可以阻塞当前线程，直到目标线程执行完毕。这在多线程编程中很有用，因为它可以保证多个线程按照一定的顺序执行，充分发挥并发性能。 线程yield是指让出CPU控制权，将当前线程从运行状态转换为就绪状态，让其他具有相同或更高优先级的线程有机会获得CPU执行时间。通过调用yield方法，可以在多个线程之间共享CPU资源，避免某个线程长时间占用CPU，提高程序的执行效率。 线程sleep是指让当前线程暂停执行一段时间。通过调用sleep方法，可以让线程休眠一段指定的时间，然后再继续执行。这在需要控制线程的执行节奏或者模拟实际场景的等待时间时特别有用。例如，在定时任务中，可以使用sleep方法来实现定时执行的功能。 总而言之，线程join、yield和sleep都是用于控制线程行为的方法，它们分别用于线程等待执行完毕、让出CPU控制权和线程休眠。它们在多线程编程中起到了重要的作用，并且可以根据具体需求灵活运用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值