码迷,mamicode.com
首页 > 编程语言 > 详细

【搞懂Java多线程之二】多线程调度及守护进程

时间:2015-04-07 12:07:13      阅读:217      评论:0      收藏:0      [点我收藏+]

标签:java多线程   进程调度   守护进程   

在前一篇文章中说到,所有处在就绪状态中的线程,操作系统会选择优先级最高的优先进行调度,那么是不是优先级高的线程就一定比优先级低的线程先执行呢?线程的优先级又是怎么划分的呢?这篇文章,楼楼就要来说说这个问题啦!欢迎关注我的个人博客主页www.anycodex.com

1.线程的优先级


在Java中,线程优先级的范围为0-10,整数值越大,说明优先级更高。

  • 几个相关的宏定义:
MAX_PRIORITY 10,最高优先级

MIN_PRIORITY 1,最低优先级

NORM_PRIORITY 5,默认优先级

  • 相关的接口
setPriority(int x),设置线程的优先级

getPriority(),获取线程的优先级

既然线程之间有优先级,那是不是优先级高的就一定比优先级低的线程先执行呢?答案是不是的。只能说优先级高的线程有更大的可能性获得CPU,但这并不意味着就一定会先执行。

小伙伴们,我们下面来看一段代码的例子吧,呼呼(~ o ~)~zZ

package net.mindview.util;

//第一步、实现Runnable接口
class MyThreadRunning implements Runnable
{
    
    //第二步、重写run方法
    public void run() {
        for (int i = 0; i <= 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

public class MyThread {
    public static void main(String[] args) {
        
        //第三步、实例化自定义的线程类对象
        MyThreadRunning mtr1 = new MyThreadRunning();
        MyThreadRunning mtr2 = new MyThreadRunning();
        MyThreadRunning mtr3 = new MyThreadRunning();
        //第四步、实例化一个Thread类对象并将自定义的线程类对象作为参数传入,后面一个参数为线程名
        Thread thread1 = new Thread(mtr1, "Thread 1 is running");
        Thread thread2 = new Thread(mtr2, "Thread 2 is running");
        Thread thread3 = new Thread(mtr3, "Thread 3 is running");
        
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread2.setPriority(Thread.MIN_PRIORITY);
        thread3.setPriority(Thread.NORM_PRIORITY);
        //第五步、调用start方法启动线程
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
运行结果:

Thread 1 is running
Thread 1 is running
Thread 2 is running
Thread 1 is running
Thread 3 is running
Thread 3 is running
Thread 3 is running
Thread 3 is running
Thread 1 is running
Thread 2 is running
Thread 2 is running
Thread 2 is running

当当当,小伙伴们是不是明白了呢?优先级高的线程原来并不一定会先执行啊?只是有比较大的可能会获得CPU调度。小伙伴们,可能会问,都设定优先级了,还是不能保证线程按照我所希望的先后顺序去执行,我还有什么招呢?嗯,看完下面的内容,你就能学到一些招了,它就是我们的线程调度。

2.线程调度


关于线程调度,我们需要了解,只有良好的调度,才能发挥良好的系统性能,提高程序的执行效率。但是,再怎么好的调度,也都无法精确的控制程序的运行。通常我们采用线程调度的方法主要有sleep,yield和join等方法。下面我们一个一个看哈!

sleep()方法,sleep就如英文意思所释,睡眠。当某个程序进入睡眠状态时,就会将CPU资源交给其他线程,而当休眠时间到时,程序又自动由阻塞状态进入就绪状态,等待CPU资源的调度。sleep()参数是毫秒级的,如sleep(1000)是让线程休眠1s。调用这个方法的时候,需要捕获InterruptedException异常。看下面的代码吧

package net.mindview.util;

//第一步、实现Runnable接口
class MyThreadRunning implements Runnable
{
    
    //第二步、重写run方法
    public void run() {
        for (int i = 0; i <= 3; i++) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

public class MyThread {
    public static void main(String[] args) {
        
        //第三步、实例化自定义的线程类对象
        MyThreadRunning mtr1 = new MyThreadRunning();
        MyThreadRunning mtr2 = new MyThreadRunning();
        MyThreadRunning mtr3 = new MyThreadRunning();
        //第四步、实例化一个Thread类对象并将自定义的线程类对象作为参数传入,后面一个参数为线程名
        Thread thread1 = new Thread(mtr1, "Thread 1 is running");
        Thread thread2 = new Thread(mtr2, "Thread 2 is running");
        Thread thread3 = new Thread(mtr3, "Thread 3 is running");
        
        //第五步、调用start方法启动线程
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
运行结果:

Thread 2 is running
Thread 3 is running
Thread 1 is running
Thread 3 is running
Thread 2 is running
Thread 1 is running
Thread 2 is running
Thread 1 is running
Thread 3 is running
Thread 3 is running
Thread 2 is running
Thread 1 is running

从运行结果中可以看出,线程无法精确的控制先后顺序。每次运行结果都有可能不一样。

  • yield方法
yield方法也像英文的意思一样,就是让步。暂停当前线程,让出CPU运行时间,进入就绪状态,从而让其他线程获得CPU时间。不过对于抢占式操作系统没有什么意义,或者说没有效果。

package net.mindview.util;

//第一步、实现Runnable接口
class MyThreadRunning1 implements Runnable
{
    
    //第二步、重写run方法
    public void run() {
        for (int i = 0; i <= 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

//第一步、实现Runnable接口
class MyThreadRunning2 implements Runnable
{
    
    //第二步、重写run方法
    public void run() {
        for (int i = 0; i <= 3; i++) {
            System.out.println(Thread.currentThread().getName());
            Thread.yield();
        }
    }
}

public class MyThread {
    public static void main(String[] args) {
        
        //第三步、实例化自定义的线程类对象
        MyThreadRunning1 mtr1 = new MyThreadRunning1();
        MyThreadRunning2 mtr2 = new MyThreadRunning2();

        //第四步、实例化一个Thread类对象并将自定义的线程类对象作为参数传入,后面一个参数为线程名
        Thread thread1 = new Thread(mtr1, "Thread 1 is running");
        Thread thread2 = new Thread(mtr2, "Thread 2 is running");
        
        //第五步、调用start方法启动线程
        thread1.start();
        thread2.start();
    }
}
运行效果: 如果不加yield的可能的运行结果:

Thread 1 is running Thread 1 is running
Thread 2 is running Thread 2 is running
Thread 1 is running Thread 1 is running
Thread 2 is running Thread 1 is running
Thread 1 is running Thread 1 is running
Thread 2 is running Thread 2 is running
Thread 1 is running Thread 2 is running
Thread 2 is running Thread 2 is running

从运行效果中可以看出,线程2每执行一次就会让出CPU资源一次,但也只是可能的运行结果。

  • join方法
join方法的作用可能从英文意思上理解不是那么简单,那其实呢,join方法的作用是想让一个线程等待另一个线程执行完毕后再继续执行。可以添加参数,long类型的毫秒,等待该进程终止最长为多少秒。如thread.mt()就是等thread线程执行完之后,再执行其他的程序。我们可以看下面的代码:
package net.mindview.util;

//第一步、继承Thread类
class MyThreadRunning extends Thread
{
    //构造函数
    public MyThreadRunning() {
        super("My Thread");
    }
    
    //第二步、重写run方法
    public void run() {
        for (int i = 0; i <= 3; i++) {
            System.out.println("新建一个线程" + getName()+i);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }
}

public class MyThread {
    public static void main(String[] args) {
        
        //第三步、实例化自定义的线程类对象
        MyThreadRunning mtr = new MyThreadRunning();
        
        
        //第四步、调用start方法从而启动run方法
        mtr.start();  
        
        try {
            mtr.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        System.out.println("mtr你执行完了是吧?我是主线程,我要来打印了。");
    }
}
运行结果:

新建一个线程My Thread0
新建一个线程My Thread1
新建一个线程My Thread2
新建一个线程My Thread3
mtr你执行完了是吧?我是主线程,我要来打印了。

3.守护进程


守护进程也叫后台进程,是一种为其他线程提供服务的一种线程。当虚拟机检测到没有用户进程执行了的话,即使还有后台进程,JVM也有可能会退出的。

相关接口:

setDaemon(boolean)将一个线程设置为后台进程;

Thread.isDaemon()判断一个线程是否为后台进程。

我们可以来看下面的代码:
package net.mindview.util;

//第一步、继承Thread类
public class MyThread { 
    public static void main(String[] args) { 
            Thread t1 = new MyCommon(); 
            Thread t2 = new Thread(new MyDaemon()); 
            t2.setDaemon(true);        //设置为守护线程 

            t2.start(); 
            t1.start(); 
    } 
} 

class MyCommon extends Thread { 
    public void run() { 
            for (int i = 0; i < 5; i++) { 
                    System.out.println("线程1第" + i + "次执行!"); 
                    try { 
                            Thread.sleep(7); 
                    } catch (InterruptedException e) { 
                            e.printStackTrace(); 
                    } 
            } 
    } 
} 

class MyDaemon implements Runnable { 
    public void run() { 
            for (long i = 0; i < 9999999L; i++) { 
                    System.out.println("后台线程第" + i + "次执行!"); 
                    try { 
                            Thread.sleep(7); 
                    } catch (InterruptedException e) { 
                            e.printStackTrace(); 
                    } 
            } 
    } 
}
运行结果:

线程1第0次执行!
后台线程第0次执行!
后台线程第1次执行!
线程1第1次执行!
线程1第2次执行!
后台线程第2次执行!
线程1第3次执行!
后台线程第3次执行!
线程1第4次执行!
后台线程第4次执行!
后台线程第5次执行!

同学们,由运行结果中是不是可以看出,后台线程还没有执行完呢,程序就退出了。



以上就是我们关于Java多线程的第二部分内容了,总结一下,这篇文章主要讲Java多线程的调度问题。调度方法主要有睡眠啊,让步啊,以及join啊之类的。但是要清楚,无论程序员怎么进行调度,也都无法实现线程的精确控制。当时良好的线程调度可以提高程序运行的效率。最后我们讲到守护线程,也就是后台线程,这里需要注意的事,虚拟机检测到没有用户线程运行了的话,不管有没有后台线程,都会退出。嗯,就这么多了,小伙伴们,都掌握了吗?下面一篇文章,我们要学习的是经典问题,生产者和消费者之类的线程同步问题,加油加油加油,未完待续哦~~~

【搞懂Java多线程之二】多线程调度及守护进程

标签:java多线程   进程调度   守护进程   

原文地址:http://blog.csdn.net/xiaxia__/article/details/44916783

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!