为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 线程的一些控制方法

线程的一些控制方法

标签：
Java

一、Java 中的线程状态转换：
线程状态转换
【注】不是 start 之后就立刻开始执行，只是就绪了(CPU 可能正在运行其他的线程)。只有被 CPU 调度之后，线程才开始执行，当 CPU 分配给的时间片到了，又回到就绪状态，继续排队等候。

二、线程控制的基本方法：

  1. isAlive()：判断线程是否还活着。start 之后，终止之前都是活的；
  2. getPriority()：获得线程的优先级数值；
  3. setPriority()：设置线程的优先级数值(线程室友优先级别的)；
  4. Thread.sleep()：将当前线程睡眠指定毫秒数；
  5. join()：调用某线程的该方法，将当前线程与该线程合并，也即等待该线程结束后，再恢复当前线程的运行状态(比如在线程B中调用了线程A的 join() 方法，直到线程A执行完毕后，才会继续执行线程B)；
  6. yield()：当前线程让出 CPU，进入就绪状态，等待 CPU 的再次调度；
  7. wait()：当前线程进入对象的 wait pool；
  8. notify()/notifyAll()：唤醒对象的 wait pool 中的一个/所有的等待线程。

三、sleep()方法：

  1. 可以调用 Thread 的静态方法：
    public static void sleep(long millis) throws InterruptedException：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响, 该线程不丢失任何监视器的所属权。InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除
  2. 由于是静态方法，sleep() 可以由类名直接调用：Thread.sleep(.....);

Demo_1:

import java.util.*;
class TestThread {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {                   // 在哪个线程中调用 Sleep，就让哪个线程睡眠
            Thread.sleep(8000); // 主线程睡8秒后，打断子线程
        } catch (InterruptedException e) {
        }
        thread.interrupt();     // 打断子线程
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        while(true){
            System.out.println("=== "+ new Date()+" ===");
            try {
                sleep(1000); // 每隔一秒打印一次日期
            } catch (InterruptedException e) {
                return;
            }
        }
    }  
}

运行结果：

=== Tue May 09 11:09:43 CST 2017 ===
=== Tue May 09 11:09:44 CST 2017 ===
=== Tue May 09 11:09:45 CST 2017 ===
=== Tue May 09 11:09:46 CST 2017 ===
=== Tue May 09 11:09:47 CST 2017 ===
=== Tue May 09 11:09:48 CST 2017 ===
=== Tue May 09 11:09:49 CST 2017 ===
=== Tue May 09 11:09:50 CST 2017 ===

子线程每隔一秒打印系统日期，主线程睡眠8秒后，打断子线程，子线程结束。

Demo_2: 在本例中，采用一种简单、粗暴、好用的方法中断子线程：

import java.util.*;
class TestThread {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {                    // 在哪个线程中调用 Sleep，就让哪个线程睡眠
            Thread.sleep(5000); // 主线程睡8秒后，打断子线程
        } catch (InterruptedException e) {
        }
        thread.flag = false; // 打断子线程
    }
}
class MyThread extends Thread {
    boolean  flag = true;
    @Override
    public void run() {
        while(flag){
            System.out.println("=== "+ new Date()+" ===");
            try {
                sleep(1000); // 每隔一秒打印一次日期
            } catch (InterruptedException e) {
            }
        }
    }
}

运行结果：

=== Tue May 09 12:21:24 CST 2017 ===
=== Tue May 09 12:21:25 CST 2017 ===
=== Tue May 09 12:21:26 CST 2017 ===
=== Tue May 09 12:21:27 CST 2017 ===
=== Tue May 09 12:21:28 CST 2017 ===

四、join()方法：合并某个线程, 相当于方法的调用

Demo_3:

class TestThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("childThread");
        myThread.start();
        try {
            myThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i = 1; i <= 4; i++){
            System.out.println("I am the mainThread");
        }
    }
}
class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for(int i = 1; i <= 4; i++){
            System.out.println("I am " + getName());
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

运行结果：

I am childThread
I am childThread
I am childThread
I am childThread
I am the mainThread
I am the mainThread
I am the mainThread
I am the mainThread

等待线程结束后, 再恢复当前线程的运行.

五、yield()方法：让出 CPU，当前线程进入就绪状态队列等待，给其他线程执行的机会(就让很小的一个时间片段)。

Demo_4：

class TestThread {
    public static void main(String[] args) {
        MyThread my1 = new MyThread("t1");
        MyThread my2 = new MyThread("t2");
        my1.start();
        my2.start();
    }
}
class MyThread extends Thread {
    public MyThread(String s) {
        super(s);
    }
    @Override
    public void run() {
        for(int i = 1; i <= 100; i++){
            System.out.println(getName()+":"+i);
            if(i % 10 == 0) {
                Thread.yield(); // 当前线程让出 CPU 一小会
            }
        }
    }  
}

六、判定线程是否处于活动状态

/**
 * 判定线程是否处于活动状态 : --就绪状态 --运行状态 --阻塞状态
 */
public class Demo2 {
	public static void main(String[] args) {
		new ThreadB().start();
	}
}
 
class ThreadB extends Thread {
	@Override
	public void run() {
		System.out.println("检测线程是否是活动状态");
		System.out.println(Thread.currentThread().isAlive());
	}
}

七、设置线程的优先级

/**
 * 设置线程优先级 MAX_PRIORITY:最大为10 MIN_PRIORITY:最小为1 DEFAULT_PRIORITY:默认为5
 * 
 * @author wxb
 *
 */
public class Demo4 {
	public static void main(String[] args) {
		ThreadD td = new ThreadD();
		ThreadE te = new ThreadE();
		td.start();// 谁先启动，谁抢占资源的概率越大
		te.start();
		td.setPriority(Thread.MAX_PRIORITY);// 设置优先级为最大，10
		te.setPriority(Thread.MIN_PRIORITY);// 设置优先级为最小，1
	}
}
 
class ThreadD extends Thread {
	@Override
	public void run() {
		// 默认优先级为5
		// System.out.println(Thread.currentThread().getPriority());
		for (int i = 0; i < 10; i++) {
			System.out.println("ThreadD j---" + i);
		}
	}
}
 
class ThreadE extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("ThreadE i---" + i);
		}
	}
}

ThreadD j---0
ThreadE i---0
ThreadE i---1
ThreadE i---2
ThreadE i---3
ThreadE i---4
ThreadE i---5
ThreadE i---6
ThreadE i---7
ThreadE i---8
ThreadE i---9
ThreadD j---1
ThreadD j---2
ThreadD j---3
ThreadD j---4
ThreadD j---5
ThreadD j---6
ThreadD j---7
ThreadD j---8
ThreadD j---9

八、守护线程，必须在它的start方法之前进行设置，通过setDaemon方法传入true的参数，当程序只有守护线程时，该程序就可以结束运行了。

/**
 * 守护线程 在线程启动前设置setDaemon(true)
 */
public class Demo6 {
	public static void main(String[] args) throws Exception {
		ThreadH th = new ThreadH();
		th.setDaemon(true);// 让当前线程设置为守护线程
		th.start();
		for (int i = 0; i < 10; i++) {
			Thread.sleep(1000);
			System.out.println("主线程。。。" + i);
		}
	}
}
 
class ThreadH extends Thread {
	int i;
	@Override
	public void run() {
		while (true) {
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Hello,---" + ++i);
		}
	}
}
点击查看更多内容
发表于 2019.09.02 20:58， 共 1353 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
1人点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

Oraclea

JAVA开发工程师
手记
篇
粉丝
37
获赞与收藏
353

关注作者，订阅最新文章

阅读免费教程

感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消