一,休眠线程
public static void sleep(long millis) throws InterruptedException
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
参数:millis - 以毫秒为单位的休眠时间。
抛出:InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时,当前线程的中断状态 被清除。
package com.yy.threadmethod;
public class Demo3_Sleep {
/**
*
*当父亲坏了,那么,儿子不能比父亲更坏
*当父亲没坏,儿子如果有坏的东西,必须自己去处理
*
* public static void sleep(long millis)
* throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
*
* 参数:millis - 以毫秒为单位的休眠时间。
* 抛出:InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时,当前线程的中断状态 被清除。
*
* */
public static void main(String[] args) throws InterruptedException {
demo1(); //创建一条线程,对其进行睡眠,使其每秒打印一次
demo2(); //创建两条线程,分别进行睡眠,让两条线程交替输出
}
private static void demo2() {
new Thread(){ //父类Thread类里面的run方法是没有throw抛异常的,子类在重写父类的方法的时候,就不能去抛异常,这里只能抓异常surround
public void run(){
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "......aaaaaa");
}
}
}.start();
//开启一条线程
new Thread(){
public void run(){
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "......bbbb");
}
}
}.start();
//开启另一条线程
}
private static void demo1() throws InterruptedException {
for (int i = 20; i >= 0; i--) {
System.out.println("倒计时:" + i + "秒");
Thread.sleep(100);
}
}
}
二,守护线程
守护线程:设置一个线程为守护线程,该线程不会单独执行,当其他的非守护线程都结束后,自动退出,退出的时候会有一定的缓冲时间,不会立马就结束;
public final void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。 该方法必须在启动线程前调用。
参数:on - 如果为 true,则将该线程标记为守护线程。
被标记成守护线程的线程,相当于象棋里的車马象士,而没被标记为守护线程的线程,相当与将帅。
package com.yy.threadmethod;
public class Demo4_Daemon {
/**
* 守护线程
* 设置一个线程为守护线程,该线程不会单独执行,当其他的非守护线程都结束后,自动退出,退出的时候会有一定的缓冲时间,不会立马就结束
*
* */
public static void main(String[] args) {
Thread t1 = new Thread(){ //匿名内部类
public void run(){ //重写run()方法
for (int i = 0; i < 2; i++) {
System.out.println(getName() + "...wsq" );
}
}
};
Thread t2 = new Thread(){
public void run(){
for (int i = 0; i < 50; i++) {
System.out.println(getName() + "...yy" );
}
}
};
t2.setDaemon(true); //当传入true就是意味着设置为守护线程,把t2设置成守护线程,相当于象棋中的車马象士,去守护t1,ti就相当于是将帅’
t1.start();
t2.start();
}
}
三,加入线程
join():当前线程暂停,等待指定的线程执行结束之后,当前线程再继续
join(int):join()的一个重载方法,可以等待指定的毫秒之后继续
- public final void join()
throws InterruptedException等待该线程终止。 抛出:
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时,当前线程的中断状态 被清除。public final void join(long millis,int nanos)
throws InterruptedException等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。- 参数:
millis - 以毫秒为单位的等待时间。
nanos - 要等待的 0-999999 附加纳秒。 - 抛出:
IllegalArgumentException - 如果 millis 值为负,则 nanos 的值不在 0-999999 范围内。
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时,当前线程的中断状态 被清除。
package com.yy.threadmethod;
public class Demo5_Join {
public static void main(String[] args) {
final Thread t1 = new Thread(){ //匿名内部类(局部内部类)在使用它所在方法中的局部变量的时候,必须用final修饰
public void run(){
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "..." + "海阔天空");
}
}
};
Thread t2 = new Thread(){
public void run(){
for (int i = 0; i < 10; i++) {
if(i == 2){ //当i=2时,也就是t2执行两次之后,t1线程开始插队
try {
// t1.join(); //这表示t1线程开始插队,然后,直到t1线程运行完毕后,才轮到t2线程运行
t1.join(1); //这表示t1线程插队,插队1毫秒之后,两条线程继续交替进行,也就是继续多线程进行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(getName() + "..." + "光辉岁月");
}
}
};
t1.start();
t2.start();
}
}
四,礼让线程
yield:礼让线程,让出CPU
public static void yield() 暂停当前正在执行的线程对象,并执行其他线程。
package com.yy.threadmethod;
public class Demo6_Yield {
public static void main(String[] args) {
new MyThread().start(); //定义一条线程
new MyThread().start(); //定义另一条线程
}
}
class MyThread extends Thread{
public void run(){
for (int i = 1; i <= 1000; i++) {
if(i % 10 == 0){ //若i是10的倍数
Thread.yield(); //让出CPU,让另一条线程进行
}
System.out.println(getName() + "..." + i);
}
}
}