Java 控制线程

Java 的线程支持提供了一些便捷的工具方法,通过这些便捷的工具方法可以很好地控制线程的执行。

join 线程

Thread 提供了让一个线程等待另一个线程完成的方法—— join() 方法。当在某个程序执行流中调用其他线程的join()方法时,调用线程将被阻塞,直到被 join() 方法加入的 join 线程执行完为止。

join() 方法通常由使用线程的程序调用,以将大问题划分成许多小问题,每个小问题分配一个线程。当所有的小问题都得到处理后,再调用主线程来进一步操作。

public class JoinThread extends Thread{
    // 提供一个有参数的构造器,用于设置该线程的名字
    public JoinThread(String name) {
        super(name);
    }
    //重写run()方法,定义线程执行体
    public void run() {
        for (int i=0 ; i < 100; i++) {
            System.out.println(this.getName() + "  " + i);
        }
    }
    public static void main(String[] args) throws Exception {
        //启动子线程
        new JoinThread("新线程").start();
        for(int i=0 ; i < 100; i++) {
            if(i==20) {
                JoinThread jt = new JoinThread("被Join的线程");
                jt.start();
                // main线程调用了 jt 线程的 join() 方法
                // main线程必须等jt执行结束后才会向下执行
                jt.join();
            }
            System.out.println(Thread.currentThread().getName() + "  " + i);
        }
    }
}

上面程序中一共有3个线程,主方法开始时就启动了名为“新线程”的子线程,该子线程将会和main 线程并发执行。当主线程的循环变量 i 等于20时,启动了名为“被 Join 的线程”的线程,该线程不会和 main 线程并发执行 , main 线程必须等该线程执行结束后才可以向下执行。在名为“被 Join 的线程”的线程执行时,实际上只有2个子线程并发执行,而主线程处于等待状态。运行上面程序,会看到如下图所示的运行效果。

主线程执行到 i == 20时,程序启动并 join 了名为“被 Join 的线程”的线程,所以主线程将一直处于阻塞状态,直到名为“被 Join 的线程”的线程执行完成。

join() 方法有如下三种重载形式:

1、join() : 等待被 join 的线程执行完成。

2、join(long  millis) : 等 待 被 join 的线程的时间最长为millis 毫秒。如果在 millis 毫秒内被 join 的线程还没有执行结束,则不再等待。

3、join(long millis, int nanos ) : 等待被 join 的线程的时间最长为 millis 毫秒加 nanos 毫微秒。

提示:通常很少使用第三种形式,原因有两个:程序对时间的精度无须精确到毫微秒;计算机硬件、操作系统本身也无法精确到毫微秒。

后台线程

有一种线程,它是在后台运行的,它的任务是为其他的线程提供服务,这种线程被称为“后台线程 ( Daemon Thread )”,又称为“守护线程”或“精灵线程”。 JVM 的垃圾回收线程就是典型的后台线程。

后台线程有个特征:如果所有的前台线程都死亡,后台线程会自动死亡。

调用 Thread 对象的 setDaemon(true) 方法可将指定线程设置成后台线程。下面程序将执行线程设置成后台线程,可以看到当所有的前台线程死亡时,后台线程随之死亡。当整个虚拟机中只剩下后台线程时,程序就没有继续运行的必要了,所以虚拟机也就退出了。

public class DaemonThread extends Thread {
    // 定义后台线程的线程执行体与普通线程没有任何区别
    public void run() {
        for (int i=0 ; i < 1000; i++) {
            System.out.println(this.getName() + "  " + i);
        }
    }

    public static void main(String[] args) {
        DaemonThread t = new DaemonThread();
        // 将此线程设置为后台线程
        t.setDaemon(true);
        // 启动后台线程
        t.start();
        for (int i=0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "  " + i);
        }
        // ---------程序执行到此处,前台线程(main线程)结束----------
        // 后台线程也应该随之结束
    }
}

上面程序中的粗体字代码先将t线程设置成后台线程,然后启动该线程,本来该线程应该执行到 i 等于999时才会结束,但运行程序时不难发现该后台线程无法运行到999,因为当主线程也就是程序中唯一的前台线程运行结束后,JVM会主动退出,因而后台线程也就被结束了。

Thread类还提供了一个 isDaemon() 方法,用于判断指定线程是否为后台线程。

从上面程序可以看出,主线程默认是前台线程,t线程默认也是前台线程。并不是所有的线程默认都是前台线程,有些线程默认就是后台线程——前台线程创建的子线程默认是前台线程,后台线程创建的子线程默认是后台线程。

注意:前台线程死亡后, JVM 会通知后台线程死亡,但从它接收指令到做出响应,需要一定时间。而且要将某个线程设置为后台线程,必须在该线程启动之前设置,也就是说,setDaemon(true) 必须在 start() 方法之前调用,否则会引发 IllegalThreadStateException异常。

线程睡眠:sleep

如果需要让当前正在执行的线程暂停一段时间,并进入阻塞状态,则可以通过调用Thread类的静态sleep()方法来实现。sleep()方法有两种重载形式。

1、static void sleep(long millis):让当前正在执行的线程暂停millis毫秒,并进入阻塞状态,该方法受到系统计时器和线程调度器的精度与准确度的影响。

2、static void sleep(long millis, int nanos):让当前正在执行的线程暂停 millis 毫秒加 nanos 毫微秒,并进入阻塞状态,该方法受到系统计时器和线程调度器的精度与准确度的影响。

与前面类似的是,程序很少调用第二种形式的sleep() 方法。

当当前线程调用 sleep() 方法进入阻塞状态后,在其睡眠时间段内,该线程不会获得执行的机会,即使系统中没有其他可执行的线程,处于 sleep() 中的线程也不会执行,因此 sleep()方法常用来暂停程序的执行。

下面程序调用 sleep()方法来暂停主线程的执行,因为该程序只有一个主线程,当主线程进入睡眠后,系统没有可执行的线程,所以可以看到程序在sleep()方法处暂停。

public class SleepTest {
    public static void main(String[] args) throws Exception {
        for(int i=0;i<10;i++) {
            System.out.println("当前时间:"+new Date());
            // 调用sleep() 方法让当前线程暂停1s
            Thread.sleep(1000);
        }
    }
}

上面程序中的粗体字代码将当前执行的线程暂停 1 秒,运行上面程序,看到程序依次输出10条字符串,输出2条字符串之间的时间间隔为1秒。

线程让步: yield

yield() 方法是一个和 sleep() 方法有点相似的方法,它也是 Thread 类提供的一个静态方法,它也可以让当前正在执行的线程暂停,但它不会阻塞该线程,它只是将该线程转入就绪状态。 yield() 只是让当前线程暂停一下,让系统的线程调度器重新调度一次,完全可能的情况是:当某个线程调用了 yield() 方法暂停之后,线程调度器又将其调度出来重新执行。

实际上,当某个线程调用了 yield()方法暂停之后,只有优先级与当前线程相同,或者优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会。下面程序使用 yield() 方法来让当前正在执行的线程暂停。

public class YieldTest extends Thread{
    public YieldTest(String name) {
        super(name);
    }
    // 定义run()方法作为线程执行体
    public void run() {
        for(int i=0;i<50;i++) {
            System.out.println(getName()+"   "+i);
            // 当 i等于20时,使用 yield() 方法让当前线程让步
            if(i==20) {
                Thread.yield();
            }
        }
    }
    public static void main(String[] args) {
        // 启动两个并发线程
        YieldTest yt1 = new YieldTest("高级");
        // 将yt1线程设置成最高优先级
        // yt1.setPriority(Thread.MAX_PRIORITY);
        yt1.start();
        YieldTest yt2 = new YieldTest("低级");
        // 将yt2线程设置成最低优先级
        // yt2.setPriority(Thread.MIN_PRIORITY);
        yt2.start();
    }
}

注意:在多 CPU 并行的环境下, yield() 方法的功能有时候并不明显。

关于 sleep() 方法和 yield() 方法的区别如下。

1、sleep() 方法暂停当前线程后,会给其他线程执行机会,不会理会其他线程的优先级;但 yield() 方法只会给优先级相同,或优先级更高的线程执行机会。

2、sleep() 方法会将线程转入阻塞状态,直到经过阻塞时间才会转入就绪状态;而 yield() 不会将线程转入阻塞状态,它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用 yield() 方法暂停之后,立即再次获得处理器资源被执行。

3、sleep() 方法声明抛出了 InterruptedException 异常,所以调用 sleep() 方法时要么捕捉该异常,要么显式声明抛出该异常;而 yield ()方法则没有声明抛出任何异常。

4、sleep() 方法比 yield() 方法有更好的可移植性,通常不建议使用 yield() 方法来控制并发线程的执行。

改变线程优先级

每个线程执行时都具有一定的优先级,优先级高的线程获得较多的执行机会,而优先级低的线程则获得较少的执行机会。

每个线程默认的优先级都与创建它的父线程的优先级相同,在默认情况下, main 线程具有普通优先级,由 main 线程创建的子线程也具有普通优先级。

Thread 类提供了 setPriority(int newPriority )、 getPriority()方法来设置和返回指定线程的优先级,其中 setPriority() 方法的参数可以是一个整数,范围是1~10之间,也可以使用 Thread 类的如下三个静态常量。

1、MAX _ PRIORITY : 其值是 10。
2、MIN _ PRIORITY : 其值是 1 。
3、NORM _ PRIORITY : 其值是 5。

下面程序使用了 setPriority() 方法来改变主线程的优先级,并使用该方法改变了两个线程的优先级,从而可以看到高优先级的线程将会获得更多的执行机会。

public class PriorityTest extends Thread{
    public PriorityTest(String name) {
        super(name);
    }
    public void run() {
        for(int i=0;i<50;i++) {
            System.out.println(getName()+",其优先级是:"+getPriority()+",循环变量的值为:"+i);
        }
    }
    public static void main(String[] args) {
        // 改变主线程的优先级
        Thread.currentThread().setPriority(6);
        for(int i=0;i<30;i++) {
            if(i==10) {
                PriorityTest low = new PriorityTest("低级");
                low.start();
                System.out.println("创建之初的优先级:"+low.getPriority());
                // 设置该线程为最低优先级
                low.setPriority(Thread.MIN_PRIORITY);
            }
            if(i==20) {
                PriorityTest high = new PriorityTest("高级");
                high.start();
                System.out.println("创建之初的优先级:"+high.getPriority());
                // 设置该线程为最高优先级
                high.setPriority(Thread.MAX_PRIORITY);
            }
        }
    }
}

上面程序中的第一行粗体字代码改变了主线程的优先级为6,这样由main线程所创建的子线程的优先级默认都是6,所以程序直接输出low、high两个线程的优先级时应该看到6。接着程序将low线程的优先级设为Priority.MIN_PRIORITY,将high线程的优先级设置为Priority.MAX_PRIORITY。

运行上面程序,会看到如下图所示的效果。

值得指出的是,虽然Java提供了 10 个优先级级别,但这些优先级级别需要操作系统的支持。遗憾的是,不同操作系统上的优先级并不相同,而且也不能很好地和Java的10个优先级对应,例如Windows 2000仅提供了 7个优先级。因此应该尽量避免直接为线程指定优先级,而应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设置优先级,这样才可以保证程序具有最好的可移植性。

原文地址:https://www.cnblogs.com/jwen1994/p/10526827.html

时间: 2024-11-10 11:55:15

Java 控制线程的相关文章

Java中怎么控制线程访问资源的数量

在API中是这样来描述Semaphore 的 Semaphore 通常用于限制可以访问某些资源(物理或逻辑的)的线程数目. 一个计数信号量.从概念上讲,信号量维护了一个许可集.如有必要,在许可可用前会阻塞每一个 acquire(),然后再获取该许可.每个 release() 添加一个许可,从而可能释放一个正在阻塞的获取者.但是,不使用实际的许可对象,Semaphore 只对可用许可的号码进行计数,并采取相应的行动. 例如,下面的类使用信号量控制线程并发的数量 import java.util.c

java中线程的控制

线程的控制: Java中的线程支持提供了一些便捷的工具方法,通过这些便捷的工作方法可以更好的控制线程的执行. 一.join线程: Thread提供了让一个线程等待另一个线程完成的方法——join()方法.当某个程序执行流中调用其他线程的join方法时,调用线程将被阻塞,直到被join方法加入的join线程执行完为止. Join()方法有如下3种重载形式: 1.join():等待被join的线程执行完成. 2.join(long millis):等待被join的线程的时间最长为millis 毫秒,

Java基础——线程总结

Java基础--线程总结 一.线程是什么? 线程:一个程序里不同的执行路径. 二.如何创建线程? 两种方法创建线程: 第一种 (1)定义具体功能类实现Runnable接口,可以多次调用而实现数据共享 (2)Thread myThread = new Thread(-)          //参数为Runnable接口类型 (3)Runnable中只有一个方法 public void run(){--} //用以定义线程运行体 第二种 (1)定义一个Thread的子类并重写run()方法 clas

Java(Android)线程池

介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端执行一个异步任务你还只是如下new Thread吗? Java new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 那你就out太多了,new Thread的弊端如下: a.

java多线程 - 线程通信

当线程在系统内运行时,程序通常无法准确控制线程的轮换执行,但是可以通过一些机制来保证线程协调运行. 由同步监视器对象协调线程 实现这种功能可以借助于Object类提供的wait().notify().notifyAll()三个方法(注意,这三个方法属于Object类,不属于Thread类).这三个方法必须由同步监视器来调用,可以分为两种情况: 对于同步方法,同步监视器默认是当前实例(this),所以可以在同步方法中直接调用这三个方法: 对于同步代码块,同步监视器是synchronized后括号里

Java 并发 线程同步

Java 并发 线程同步 @author ixenos 同步 1.异步线程本身包含了执行时需要的数据和方法,不需要外部提供的资源和方法,在执行时也不关心与其并发执行的其他线程的状态和行为 2.然而,大多数实际的多线程应用中,两个或两个以上的线程需要共享对同一数据的存取,这将产生同步问题(可见性和同步性的丢失) 比如两个线程同时执行指令account[to] += amount,这不是原子操作,可能被处理如下: a)将account[to]加载到寄存器 b)增加amount c)将结果写回acco

Java(Android)线程池 总结

一种是使用Executors工厂生产线程池:另一种是直接使用ThreadPoolExecutor自定义. Executors工厂生产线程池 Java(Android)线程池 Trinea 介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端执行一个异步任务你还只是如下new Thread吗? Java 1 2 3 4 5 6 7 newThread(newRunnable(){ @Ove

Java多线程——线程同步

在之前,已经学习到了线程的创建和状态控制,但是每个线程之间几乎都没有什么太大的联系.可是有的时候,可能存在多个线程多同一个数据进行操作,这样,可能就会引用各种奇怪的问题.现在就来学习多线程对数据访问的控制吧. 由于同一进程的多个线程共享同一片存储空间,在带来方便的同时,也带来了访问冲突这个严重的问题.Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问.   一.多线程引起的数据访问安全问题 下面看一个经典的问题,银行取钱的问题: 1).你有一张银行卡,里面有50

java-线程-使用阻塞队列(BlockingQueue)控制线程通信

BlockingQueue是一个接口,也是Queue的子接口.BlockingQueue具有一个特征:当生产者线程试图向BlockingQueue中放入元素时,如果该队列已满,则线程被阻塞:但消费者线程试图从BlockingQueue中取出元素时,如果队列已空,则该线程阻塞. 程序的两个线程通过交替向BlockingQueue中放入元素.取出元素,即可很好地控制线程的通信. BlockingQueue提供如下两个支持阻塞的方法: put(E e):尝试把Eu元素放如BlockingQueue中,