java多线程之线程的调度

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_35529801/article/details/78699867
Thread.sleep(500);会让主线程睡眠500毫秒
                        线程的调度
计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执行指令。所谓多线程的并发运行,其实是从宏观上看,各个线程轮流获得CPU的使用权才能执行指令,分别执行各自的任务。在可运行池中,会有多个处于就绪态的线程在等待CPU,Java虚拟机的一项任务就是负责线程的调度。线程的调度是指按照特定的机制为多个线程分配CPU的使用权。有两种调度模型:分时调度模型和抢占式调度模型
分时调度模型是指让所有线程轮流获得CPU的使用权,并且平均分配每个线程占用CPU的时间片。
Java虚拟机采用抢占式调度模型,是指优先让可运行池中处于就绪态的线程中优先级高的占用CPU,如果可运行池中线程的优先级相同,那么就随机选择一个线程,使其占用CPU,处于运行状态的线程会一直执行,直至它不得不放弃CPU,一个线程会因为以下原因放弃CPU:
(1)Java虚拟机让当前线程暂时放弃CPU,转到就绪态,使其他线程获得运行机会
(2)当前线程因为某些原因而处于阻塞状态
(3)线程运行结束
值得注意的是,线程的调度不是跨平台的,它不仅取决于Java虚拟机,还依赖于操作系统。在某些操作系统中,即使运行中的线程没有遇到阻塞,也会在运行一段时间后放弃CPU,给其他线程运行的机会。

java线程的调度不是分时的,同时启动多个线程后,不能保证各个线程轮流获得均等的时间片

package t2;

public class Test implements Runnable {
    privatestatic StringBuffer sb = new StringBuffer();
    privatestatic int count;
    
    publicstatic void main(String[] args) throws Exception{
      // TODO Auto-generated method stub
      Thread t1= new Thread(new Test());
      Thread t2 = new Thread(new Test());
      t1.setName("线程1:");
      t2.setName("线程2:");
      t1.start();
      t2.start();
      while(t1.isAlive() || t2.isAlive() ||t3.isAlive())
      {
         Thread.sleep(500);  //主线程进入睡眠
      }
      System.out.println(sb);
    }
    public voidrun()
    {
      for(int i=0; i<20; i++)
      {
         sb.append(Thread.currentThread().getName() + i +"  ");
         if((++count) % 10 == 0)
         {
            sb.append("\n");
         }
      }
    }

}
线程1:0  线程1:1 线程1:2  线程1:3 线程1:4  线程1:5 线程1:6  线程1:7 线程1:8  线程1:9  
线程1:10  线程1:11 线程1:12  线程1:13 线程1:14  线程1:15 线程1:16  线程1:17 线程1:18  线程1:19  
线程2:0  线程2:1 线程2:2  线程2:3 线程2:4  线程2:5 线程2:6  线程2:7 线程2:8  线程2:9  
线程2:10  线程2:11 线程2:12  线程2:13 线程2:14  线程2:15 线程2:16  线程2:17 线程2:18  线程2:19  

从上面的打印结果可以看出,线程1和线程2启动后,线程1先获得CPU的使用权,进入运行状态,直至线程1结束生命周期,线程2就从就绪状态进入运行状态
如果希望明确让一个线程给另外一个线程运行的机会,可以
(1)调整各个线程的优先级
(2)让处于运行状态的线程调用Thread.sleep()方法
(3)让处于运行状态的线程调用Thread.yield()方法
(4)让处于运行状态的线程调用另一个线程的join()方法



1.调整各个线程的优先级
所有处于就绪状态的线程根据优先级存放在可运行池中,优先级低的线程获得较少的运行机会,优先级高的获得较多的运行机会。Thread类的setPriority(int)和getPriority()方法用于设置和读取优先级。优先级用整数表示,取值范围时1-10,Thread类有以下三个静态常量。
MAX_PRIORITY:取值是10,表示最高优先级
MIN_PRIORITY:取值是1,表示最低优先级
DEFAULT_PRIORITY:取值是5,表示默认优先级
每个线程都有其优先级。主线程的默认优先级是Thread.DEFAULT_PRIORITY。如果线程A创建了线程B,那么线程B就和线程A具有同样的优先级
***值得注意的是,尽管Java提供了10个优先级,但它与多数操作系统都不能很好的映射。比如windows2000有7个优先级,并且不是固定的,而sun公司的Solaris操作系统有2^31个优先级。如果希望程序能移植到各个操作系统中,应该确保在设置线程的优先级时,只使用MIN_PRIORITY,DEAULT_PRIORITY,MAX_PRIORITY这三个优先级。这样才能保证在不同的操作系统中,对同样优先级的线程采用同样的调度方式
2.线程睡眠:Thread.sleep()方法
当一个线程在运行中sleep()方法,它就会放弃cpu,转到阻塞状态。Thread类的sleep(longmillis)方法是静态的,millis参数设置睡眠的时间,单位是毫秒。
**假如线程1线程进入睡眠,线程2获得cpu,当线程1结束睡眠后,后先进入就绪状态,假如线程2正在运行,线程1并不一定会立即执行,而是在可运行池中等待获取CPU
3.线程让步:Thread.yield()方法
当线程在运行中执行了Thread类的yield()静态方法时,如果此时具有相同优先级的其他线程处于就绪状态,那么yield()方法将把当前运行的线程放到可运行池中并使另一个线程运行。如果没有相同优先级的可运行进程,则yield()方法什么也不做
sleep()方法和yield()方法都是Thread类的静态方法,都会使当前处于运行状态的线程放弃CPU,把运行机会让给别的线程。两者的区别在于:
(1)sleep()方法会给其他线程运行的机会,而不考虑其他线程的优先级,因此会给较低优先级线程一个运行的机会;yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会
(2)当线程执行sleep(longmillis)方法后,将转到阻塞状态,参数millis制定睡眠时间;当线程执行yield()方法后,将转到就绪状态
(3)sleep()方法声明抛出InterruptedException异常,而yield()方法没有声明抛出任何异常
(4)sleep()方法比yield()方法具有更好的可移植性。不能依靠yield()方法来提高程序的并发性能。对于大多数程序员来说,yield()方法的唯一用途是在测试期间人为地提高程序的并发性能,以帮助发现一些隐藏的错误。
4.等待其他线程结束:join()
当前运行的线程可以调用另一个线程的join()方法,当前运行的线程将转到阻塞状态,直至另一个线程运行结束,它才会恢复运行(阻塞恢复到就绪)
public class TestJoinImpl implements Runnable {

   @Override
    public voidrun() {
      for(int i=0; i<20; i++) {
         System.out.println(Thread.currentThread().getName()+ i);
      }
    }
    publicstatic void main(String[] args)  {
      Thread t = new Thread(new TestJoinImpl());
      t.setName("线程1:");
      t.start();
      System.out.println("main:join machine");
      
      try {
         t.join();
      } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      
      System.out.println("main:end");
    }
}
main:join machine
main:end
线程1:0
线程1:1
线程1:2
线程1:3
线程1:4
线程1:5
线程1:6
线程1:7
线程1:8
线程1:9
线程1:10
线程1:11
线程1:12
线程1:13
线程1:14
线程1:15
线程1:16
线程1:17
线程1:18
线程1:19
join()方法有两种重载方式:
public void join()
public void join(long timeout)
以上timeout参数设定当前线程被阻塞的时间,以毫秒为单位,如果超过阻塞时间,那么线程就会恢复运行
5.返回当前线程对象的引用:Thread类的currentThread()静态方法返回当前线程对象的引用
6.后台线程
后台线程是指为其他线提供服务的线程,也称为守护线程。Java虚拟机的垃圾回收线程时典型的后台线程,它负责回收其他线程不再使用的内存
后台线程的特点是:后台线程与前台线程相伴相随,只有所有的前台线程都结束生命周期。调用Thread类的setDaemaon(true)方法,就能把一个线程设置为一个后台线程。Thread类的isDaemon()方法用来判断一个线程是不是后台线程
在使用后台线程时,有以下注意点:
(1)Java虚拟机所能保证的是,当所有前台进程结束时,假如后台进程还在运行,Java虚拟机就会终止后台线程。此外,后台线程是否一定在前台线程的后面结束生命周期,还取决于程序的实现。
(2)只有在线程启动前(即调用start()方法以前),才能把它设置为后台线程。如果线程启动后,再调用这个线程的setDaemon()方法,就会导致IllegalThreadStateException异常
(3)由前台线程创建的线程在默认情况下仍然是前台线程,由后台线程创建的线程默认情况下也是后台线程
7.定时器:Timer
在start()方法中定义
public void start() {
    Timer timer= new Timer(true);  //将与Timer有关的线程设为后台线程
    TimerTasktask = new TimerTask(){
       public void run() {
         while(true) {
            任务    
         }
      }
    };
   timer.schedule(task,10,500);  //设置定时任务
}
Timer类本身不是线程类,但是在它的实现中,利用线程来执行定时任务,timer.schedule(task,100,500)表示100毫秒后执行task任务,以后每隔500毫秒执行一次
阅读更多
换一批

没有更多推荐了,返回首页