Java线程:控制线程

最新推荐文章于 2024-12-12 10:04:40 发布

gaolhjy

最新推荐文章于 2024-12-12 10:04:40 发布

阅读量1.6k

点赞数

分类专栏： JavaSe基础

本文链接：https://blog.youkuaiyun.com/gaolh89/article/details/81304808

版权

JavaSe基础专栏收录该内容

26 篇文章

订阅专栏

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

一.join线程

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

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

代码片1
public class JoinThread extends Thread {

    public JoinThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "  " + i);
        }
    }
}

代码片2
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new JoinThread("新线程").start();
        for (int i = 0; i < 100; i++) {
            if (i == 20) {
                JoinThread jt = new JoinThread("被Join的线程");
                jt.start();
                try {
                    jt.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            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毫微秒。

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

二.后台线程

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

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

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

代码片3
public class DaemonThread extends Thread {

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

在main函数中:

代码片4
 DaemonThread thread = new DaemonThread();
 thread.setDaemon(true);
 thread.start();
 for (int i = 0; i < 10; i++) {
     System.out.println("主线程:" + Thread.currentThread().getName() + "  " + i);
 }

在代码片4中第3行,先将线程设置成后台线程,然后启动该线程,本来该线程应该执行到i等于9999时才会结束,但运行程序时不难发现该后台线程无法运行到9999,因为当主线程也就是程序中的唯一前台线程运行结束后,JVM会主动退出,因此后台线程也就被结束了。
在这里插入图片描述
如果按照上面的说法,后台程序应该需要到i==9时就停止了,但日志截图显示为90584才结束,这是为什么呢?

因为前台线程死亡后,JVM会通知后台线程死亡,但从它接收指定到做出响应,需要一定时间。

并且,要将某个线程设置为后台线程,必须在该线程启动之前设置,也就是说,setDaemon()方法必须在start()方法之前,否则会引发IllegalThreadStateException异常。

三.线程睡眠: sleep

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

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

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

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

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

       try {
            for (int i = 0; i < 10; i++) {
                System.out.println("当前时间:" + new Date());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

在这里插入图片描述
上面程序中的代码 Thread.sleep(1000); 将当前执行的线程暂停1秒，运行上面程序，看到程序依次输出10 条字符串，输出2条字符串之间的时间间隔为1 秒。

四.线程让步: yield

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

实际上，当某个线程调用了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)throws Exception
	{
		// 启动两条并发线程
		YieldTest yt1 = new YieldTest("高级");
		// 将ty1线程设置成最高优先级
		yt1.setPriority(Thread.MAX_PRIORITY);
		yt1.start();
		YieldTest yt2 = new YieldTest("低级");
		// 将yt2线程设置成最低优先级
		yt2.setPriority(Thread.MIN_PRIORITY);
		yt2.start();
	}
}

上面程序中的第16行代码调用yield()静态方法让当前正在执行的线程暂停，让系统线程调度器重新调度。由于程序中第25行、29行代码处于注释状态——即两个线程的优先级完全一样，所以当一个线程使用yield（）方法暂停后，另一个线程就会开始执行。运行上面程序，会看到如图16.6所示的运行结果。

如果将YieldTest.java 程序中设置优先级的代码(即第25行、29行代码)注释取消，也就是为两个线程分别设置不同的优先级，则程序的运行结果如图16.7 所示。

在这里插入图片描述注意:
在多CPU并行的环境下,yield()方法的功能有时并不明显,如果大家使用多CPU机器运行上述程序,则可能看不到如图16.6和图16.7的效果。

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

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

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

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

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

五.改变线程优先级

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

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

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

MAX_ PRIORITY:其值是10。
MIN PRIORITY: 其值是1。
NORM PRIORITY: 其值是5。

通过设置setPriority( )方法来改变主线程的优先级,并使用该方法改变了两个线程的优先级,高优先级的线程将会获取更多的执行机会。

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