线程调度

最新推荐文章于 2024-07-19 01:16:39 发布
置顶 最新推荐文章于 2024-07-19 01:16:39 发布
阅读量634 收藏
点赞数
分类专栏： java开发 文章标签： 多线程 线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiweicao0429/article/details/53184222
版权

上一篇文章是初步了解多线程，以及多线程的java实现，现在我们围绕线程状态的关系图，分析线程状态间的调度。




isalive()判断线程是否启动

package thread;
/**
 * 
 * 判断线程是否启动
 * @author shangwei
 *
 */
public class isalive implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<3;i++){
			System.out.println(Thread.currentThread().getName());
		}
	}
	
	public static void main(String[] args){
		isalive is = new isalive();
		Thread demo = new Thread(is);
		System.out.println("线程启动之前－－－"+demo.isAlive());
		demo.start();
		System.out.println("线程启动之后－－－"+demo.isAlive());
	}

}

在java中每次程序运行都会至少启动2个线程，一个是main线程，一个垃圾回收线程，每当使用java命令执行一个类的时候都会启动jvm,每一个jvm在操作系统中会生成一个进程。

我们看一下运行结果，分别出现了2种结果：

第一种：

线程启动之前－－－false

Thread-1

Thread-1

Thread-1

线程启动之后－－－false

第二种：

线程启动之前－－－false

线程启动之后－－－true

Thread-1

Thread-1

Thread-1


我们可以看出主线程可能在子线程结束之前结束，并且子线程不受影响，不会因为主线程的结束而结束。


join() 线程强制执行

package thread;
/**
 * join 指定的线程加入到当前线程
 * @author shangwei
 *
 */
public class joinTest implements Runnable{

	public static int a = 0;
	@Override
	public void run() {
		for(int k =0;k<5;k++)
		{
			a = a+1;
		}
		// TODO Auto-generated method stub
		
	}	
	public static void main(String[] args) throws Exception{
		
		Runnable r  = new joinTest();
		Thread t = new Thread(r);
		t.start();
		t.join();
		System.out.println(a);		
	}
}

请问程序的输出结果是5吗？答案是：有可能。其实你很难遇到输出5的时候，通常情况下都不是5。当然这也和机器有严重的关系。为什么呢？我的解释是 当主线程 main方法执行System.out.println(a);这条语句时，线程还没有真正开始运行，或许正在为它分配资源准备运行。因为为线程分配资源需要时间，而main方法执行完t.start()方法后继续往下执行System.out.println(a);,这个时候得到的结果是a还没有被 改变的值0  。怎样才能让输出结果为5！其实很简单，join() 方法提供了这种功能。join() 方法，它能够使调用该方法的线程在此之前执行完毕。


源代码


/** 
     *  Waits at most <code>millis</code> milliseconds for this thread to   
     * die. A timeout of <code>0</code> means to wait forever.   
     */  
    //此处A timeout of 0 means to wait forever 字面意思是永远等待，其实是等到t结束后。  
    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;  
            }  
        }  
    }

Join方法实现是通过wait（小提示：Object 提供的方法）。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁

sleep()线程的休眠

package thread;

public class sleep implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i = 0;i<3;i++){
			try{
				Thread.sleep(2000);
			}catch (Exception e){
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
	public static void main(String[] args){
		
		sleep s = new sleep();
		Thread demo = new Thread(s,"线程");
		demo.start();
				
	}

}


运行结果：结果每隔2s输出一个

线程0

线程1

线程2


interrupt()线程中断

interrupt 不会中断一个正在运行的线程，它的作用是在线程遇到阻塞的时候抛出一个中断信号，这样线程就得以退出阻塞的状态。如果线程被wait,join,sleep三种方法之一阻塞，那么它将收到一个中断一场，从而尽早的终结被阻塞的状态。

package thread;

public class interrupt implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("执行run方法");
		try {
			Thread.sleep(10000);
			System.out.println("线程休眠完成");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("休眠被打断");
			e.printStackTrace();
		}
		System.out.println("线程正常终止");
	}
	
	public static void main(String[] args){
		interrupt in = new interrupt();
		Thread t = new Thread(in,"线程");
		t.start();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t.interrupt();//2s后中断线程
	}

}

运行结果：

执行run方法

休眠被打断

java.lang.InterruptedException: sleep interrupted

at java.lang.Thread.sleep(Native Method)

at thread.interrupt.run(interrupt.java:10)

at java.lang.Thread.run(Thread.java:695)

线程正常终止

优先级

java优先级是一个整数，其取值范围是1（Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY）。

thread源代码里对NORM_PRIORITY(数值为5)的注释是‘线程的默认的优先级’

public final static int NORM_PRIORITY = 5;  

其实不然，默认的优先级是父线程的优先级，在init方法里，

  1. Thread parent = currentThread();  
  2. this.priority = parent.getPriority(); 

这里理解是因为java线程的主线程（main方法）的优先级默认是为NORM_PRIORITY,这样不主动设定优先级后，后续创建的线程的优先级也都是NORM_PRIORITY

  1. public static void main(String[] args) {  
  2.     System.out.println(Thread.currentThread().getPriority());  
  3. }  

执行结果是5


package thread;

public class priority implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"运行"+i);
		}
		
	}
	
	public static void main(String[] args){
		priority p = new priority();
		Thread t1 = new Thread(p,"A");
		Thread t2 = new Thread(p,"B");
		Thread t3 = new Thread(p,"C");
		t1.setPriority(8);
		t2.setPriority(2);
		t3.setPriority(6);
		t1.start();
		t2.start();
		t3.start();
	}
	
	

}

执行结果：

A运行0

A运行1

A运行2

A运行3

A运行4

A运行5

A运行6

A运行7

A运行8

B运行0

C运行0

A运行9

B运行1

C运行1

C运行2

C运行3

C运行4

C运行5

C运行6

C运行7

C运行8

C运行9

B运行2

B运行3

B运行4

B运行5

B运行6

B运行7

B运行8

B运行9

yield() 线程的礼让

package thread;

public class yield implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<5;++i){
			System.out.println(Thread.currentThread().getName()+"运行"+i);
			if(i ==3){
				System.out.println("线程礼让");
				Thread.currentThread().yield();
			}
		}
	}

	public static void main(String[] args){
		yield y = new yield();
		Thread t1= new Thread(y,"线程A");
		Thread t2= new Thread(y,"线程B");
		t1.start();
		t2.start();
	}
}


运行结果：

线程A运行0

线程A运行1

线程A运行2

线程A运行3

线程礼让

线程B运行0

线程B运行1

线程B运行2

线程B运行3

线程礼让

线程A运行4

线程B运行4



同步锁

还记得上一篇文章中的共享资源的案例吗？我们稍微改动下，加一个休眠时间

package thread;

public class runnable_share_4 implements Runnable {
	
	private int count = 5;
	
	public static void main(String[] args){
		runnable_share_4 h1 = new runnable_share_4();
		Thread t1 = new Thread(h1,"1号窗口");
		t1.start();
		Thread t2 = new Thread(h1,"2号窗口");
		t2.start();
		Thread t3 = new Thread(h1,"3号窗口");
		t3.start();
		
	}

	@Override
	public void run() {
		for(int i=0;i<10;++i){
			if(count >0){
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"count"+"正在卖"+count--);
			}
		}
		// TODO Auto-generated method stub
		
	}

}

运行结果：

3号窗口count正在卖5

2号窗口count正在卖4

1号窗口count正在卖4

1号窗口count正在卖3

2号窗口count正在卖1

3号窗口count正在卖2
 如果想解决这种问题，就需要使用同步，所谓同步就是同一个时间段只有一个线程运行，其他线程必须等到这个线程结束后才能继续执行。

采用同步的话，可以使用同步代码块和同步方法两种方式


［同步代码块］

语法格式：

synchronized（同步对象）{

 //需要同步的代码

}

但是一般都把当前对象this作为同步对象。

package thread;

public class synchronized_块 implements Runnable {
	
	private int count = 5;
	
	public static void main(String[] args){
		synchronized_块 h1 = new synchronized_块();
		Thread t1 = new Thread(h1,"1号窗口");
		t1.start();
		Thread t2 = new Thread(h1,"2号窗口");
		t2.start();
		Thread t3 = new Thread(h1,"3号窗口");
		t3.start();
		
	}

	@Override
	public void run() {
		for(int i=0;i<10;++i){
			synchronized(this){
			if(count >0){
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"count"+"正在卖"+count--);
			}
			}
		}
		// TODO Auto-generated method stub
		
	}

}

结果如下：

1号窗口count正在卖5

1号窗口count正在卖4

1号窗口count正在卖3

1号窗口count正在卖2

1号窗口count正在卖1

【同步方法】

也可以采用同步方法。

语法格式为synchronized 方法返回类型方法名（参数列表）{

    // 其他代码

}


 
package thread;

public class synchronized_方法 implements Runnable {
	
	private int count = 5;
	
	public static void main(String[] args){
		synchronized_方法 h1 = new synchronized_方法();
		Thread t1 = new Thread(h1,"1号窗口");
		t1.start();
		Thread t2 = new Thread(h1,"2号窗口");
		t2.start();
		Thread t3 = new Thread(h1,"3号窗口");
		t3.start();
		
	}
	
	public synchronized void sale (){
		if(count >0){
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"count"+"正在卖"+count--);
		}
		
	}

	@Override
	public void run() {
		for(int i=0;i<10;++i){
			sale();
		}
		// TODO Auto-generated method stub
		
	}

}


结果如下：

1号窗口count正在卖5

1号窗口count正在卖4

1号窗口count正在卖3

1号窗口count正在卖2

1号窗口count正在卖1


weiweicao0429
关注
专栏目录
深入理解Java线程调度算法
fudaihb的博客
06-30 870
线程调度是操作系统核心的一部分，负责管理和控制线程的执行顺序。调度算法决定了在多线程环境中，哪个线程应当被调度器选中并运行。其目标是确保所有线程能够公平地获得CPU时间，并尽可能高效地利用系统资源。本文详细介绍了Java线程调度算法的基本概念、常见调度算法、Java中的线程优先级以及调度实现细节。理解和掌握线程调度算法对于优化多线程应用程序的性能至关重要。通过合理设置线程优先级、选择合适的调度算法和避免常见的调度问题，可以有效提升系统的响应速度和资源利用率。
CUDA编程04 - GPU计算架构和线程调度
最新发布
GPU全栈博主-程序哥
08-01 1626
在前面的CUDA编程01- 并行编程介绍中，我们了解到CPU的设计目的是最小化指令执行的延迟，而GPU的设计目的是最大化执行指令的吞吐量。在前面CUDA编程02 - 数据并行介绍和CUDA编程03 - 多维数据并行中，我们学习了使用CUDA编程接口创建和调用核函数来启动和执行线程的核心特性。在接下来的三篇文章中，我们将讨论现代GPU的架构，包括计算架构和内存架构，并探讨基于架构理解之上的性能优化技术。本章将介绍GPU计算架构的几个方面，这些方面对于CUDA C程序员理解其核函数的性能和行为至关重要。
线程的调度
liujiayu2的专栏
06-16 735
概述 Windows 实现了一个由优先级驱动，抢占式的调度系统，也就是最高优先级的可运行的（就绪状态下的）线程总是先运行。 有一种现象称之为“处理器亲合（processor affinity）”，即线程可能受处理器限制，只运行在那些允许它运行的处理器上。缺省的设置是线程可运行在任何可用的处理器上，用户可以通过使用一个Win32的调度函数修改处理器的“亲合性”。 当一个线程被选择运行，它所运行
操作系统——进程与线程（CPU的调度）
2301_80636070的博客
07-19 697
作业调度从外存的后备队选择一批作业进入内存，为他们建立进程，这些进程被送入就绪队列，进程调度从一个就绪队列种选出一个进程，并将状态改为运行态，将CPU分给他。4.当I/O设备完成后，发出I/O中断，原先等待I/O的进程被阻塞态变为就绪态，此时就需要决定是让新的就绪进程投入运行，还是让中断发生时运行的进程继续执行。CPU的调度是对CPU进行分配，从就绪队列中按照一顶公平的算法选择一个进程并将CPU分配给它运行，来实现进程并发地执行。2).中级调度将暂时不能运行的程序挂起，自己调度处于作业调度和进程调度之间。
线程调度分析、监控工具（demo）
12-04
线程调度图形化分析工具，根据优先级依次分行排列线程信息：分别显示 序号、优先级、线程名、线程调度运行图形化信息 可以统计运行次数、调度次数、实际运行时间、运行总时间（含被抢占时间）、有效运行时间比...
java的线程调度器_Java线程调度方式
weixin_33501343的博客
02-16 1595
在Java多线程环境中，为保证所有线程的执行能按照一定的规则执行，JVM实现了一个线程调度器，它定义了线程调度的策略，对于CPU运算的分配都进行了规定，按照这些特定的机制为多个线程分配CPU的使用权。这小节关注线程如何进行调度，了解了java线程调度模式有助于后面并发框架的深入探讨。一般线程调度模式分为两种——抢占式调度和协同式调度。抢占式调度指的是每条线程执行的时间、线程的切换都由系统控制，系统...
线程调度方法
wd_888的博客
03-15 950
本文主要介绍线程的相关调度方法 1.sleep()方法 让当前线程暂停执⾏，从运⾏状态进⼊阻塞状态，将 CPU 资源让给其他线程的调度⽅式，通过 sleep()来实现。 sleep(long millis)，调⽤时需要传⼊休眠时间，单位为豪秒。 自定义一个线程类 public class MyThread extends Thread { @Override public voi...
什么是线程调度?
weixin_39371622的博客
09-18 4960
线程调度有两种: 1.分时调度 分时调度就是所有线程轮流拥有(使用)cpu的使用权,平均分配每个线程占用cpu的时间 2.抢占式调度 抢占式调度就是优先让优先级高的线程使用cpu,如果线程的优先级相同,则会随机选择一个,所以谁的优先级高,谁抢夺cpu的几率就越大,从而优先级高的占用cpu的时间会更长,Java为抢占式调度. 抢占式调度使cpu会在多个进程中、多个线程中来回跳转,其速度非常快:1/n...
RxJava2线程调度深度解析：subscribeOn与observeOn
"RxJava2 线程调度的方法" RxJava2是一个强大的反应式编程库，其中线程调度是其核心功能之一，它允许开发者在不同的线程间自由切换，以确保异步操作的正确执行。`subscribeOn` 和 `observeOn` 是两个关键的方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值