Thread类中的常用方法

 

获取线程名称

getName()：获取线程的名称

注意事项：

  1、如果没有给线程命名，那么线程的默认名字就是Thread-x，x是序号，从0开始

  2、可以使用对象的引用调用getName方法，也可以在线程类中，调用getName

  3、Runnable的实现类中，没有getName方法

注意】假如有三个线程，前两个都设置了名字，第三个没有设置，默认打出的名字是Thread-2而不是Thread-0

设置线程名称

setName(String name)

  使用线程对象的引用，调用该方法给线程起名字

构造方法：

  Thread(String name)：给线程通过构造方法起名字

  Thread(Runnable target, String name)：在给线程target对象赋值的同时，也给线程起名

注意事项：

  线程设置名字，既可以在启动之前设置，也可以在启动之后设置

获取当前线程对象

作用：

  某段代码只要是在执行，就一定是在某个方法中执行的，只要在某个方法中，代码就一定是被某个线程执行的。所以任意一句代码，都有执行这句代码的线程对象。

  可以在任意位置，获取当前正在执行这段代码的线程对象

方法：

  Thread  Thread.currentThread();

  返回当前正在执行这段代码的线程对象的引用

  哪条线程在执行这段代码，返回的就是哪条线程

package com.cc.thread01;

public class Demo01SetGetName {

	public static void main(String[] args) {
		Demo d1 = new Demo();
		Demo d2 = new Demo();
		d1.start();
		d2.start();
		//线程设置名字,既可以在启动之前设置,也可以在启动之后设置
		d1.setName("线程1");
		d2.setName("线程2");
		
		Thread t1 = new Thread(new Task());
		t1.start();//Thread-2
	}

}
class Demo extends Thread{
	@Override
	public void run() {
		//获取当前线程对象的名字,若不设置名字,则默认Thread-X(0/1...)
		//System.out.println(getName());
       //使用对象的引用调用getName方法
		System.out.println(this.getName());
		//Thread.currentThread() 返回当前正在执行这段代码的线程对象的引用
		//System.out.println(Thread.currentThread().getName());
	}
}
class Task implements Runnable{

	@Override
	public void run() {
		//Runnable接口中没有GetName方法,只有run()方法,只能通过Thread.currentThread().getName()获取名字
		System.out.println(Thread.currentThread().getName());
	}
}

练习

 获取主方法所在的线程名称--->main

 获取垃圾回收线程的线程名称-->Finalizer

package com.cc.thread01;
/*1.获取主线程的名称
 * 2.获取垃圾回收机制的名称*/
public class Test01gcMain {

	public static void main(String[] args) {
		//垃圾回收机制
		//创建垃圾对象,让垃圾回收机制自动运行起来
		for(int i =0;i<=100;i++) {
			//匿名对象就是垃圾对象
			new Test();//Finalizer
			//手动回收
			System.gc();
		}
		//主线程
		for(int i = 0;i<=100;i++) {
			System.out.println(Thread.currentThread().getName());
		}

	}

}
class Test{
	@Override
	protected void finalize() throws Throwable {
		//由于垃圾回收方法，被垃圾回收线程调用，所以里面的代码都是垃圾回收线程运行的
		System.out.println(Thread.currentThread().getName());
	}
}

线程休眠

1Thread.sleep(long time)

  让当前线程休眠

  time：休眠的时间，单位是毫秒

2作用：

  当某段代码在某个位置需要休息的时候，就使用线程的休眠

  无论哪个线程在运行这段代码，碰到sleep方法都需要停下休息

3注意事项：

  有一个异常，中断异常：InterruptedException

  在普通方法中，可以声明

  在run方法中，必须只能处理，不能声明

package com.cc.thread01;
/*无论哪个线程运行这段代码,只要碰到sleep方法都有停下来休息*/
public class Demo02Sleep {

	public static void main(String[] args) {
		MyCount mc = new MyCount();
		mc.start();
	}

}
/*往银行账户里面存三万元,每存一万休息一下*/
class MyCount extends Thread{
	int count = 0;
	@Override
	public void run() {
		for(int i = 0 ;i<3;i++) {
			count+=10000;
			System.out.println(count);
			//中断异常(InterruptedException)在run()方法中只能处理,不能声明.在普通方法中可以声明
			try {
				Thread.sleep(1000);//休息1000毫秒(1秒)
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

守护线程

1. setDaemon(boolean flag)：每条线程默认不是守护线程，只有设定了flag为true之后，该线程才变成守护线程
2. isDaemon()：判断某条线程是否是守护线程
3. 守护线程的特点：

  守护线程就是用于守护其他线程可以正常运行的线程，在为其他的核心线程准备良好的运行环境。如果非守护线程全部死亡，守护线程就没有存在的意义了，一段时间之后(不是立即），虚拟机也一同结束。

  4.别名：后台线程

package com.cc.thread01;

public class Demo03SetDaemon {

	public static void main(String[] args) {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				for(int i=0;i<1000;i++) {
					System.out.println("aaaaa=="+i);
				}
			}
		};
		//守护线程
		t1.setDaemon(true);
		//若没有创建其他线程,则守护主线程和垃圾线程
		t1.start();
		
		//主线程
		for(int i=0;i<=100;i++) {
			System.out.println("main===="+i);
		}
	}
}

分别从【作用上】和【代码】上：判断垃圾回收线程是否是守护线程：true

package com.cc.lianxi;

public class Demo05 {
	// 分别从【作用上】和【代码】上：判断垃圾回收线程是否是守护线程
	public static void main(String[] args) {
		new Gab();
		System.gc();
	}
}

class Gab {
	@Override
	public void finalize() {
		System.out.println(Thread.currentThread().isDaemon());
	}
}

线程优先级

1. 通过某些方法，设定当前线程的优先级，优先级高的线程先运行（在前面的时间段内，高优先级的线程会运行的多一些），优先级低的线程后运行（在后面的时间段内低优先级的线程运行多一些）
2. setPriority(int p)：通过给定优先级数字设定优先级，数字越大，优先级越高

  数字范围：最小1，自大的是10，默认状态就是5

    3.有三个优先级常量：

  MAX_PRIORITY 值为10

  NORM_PRIORITY 值是5

  MIN_PRIORITY 值为1

package com.cc.thread01;
/*优先级高的线程抢占到CUP的执行权更大一些
 * int  setPriority类型,最小为1,最大10,默认为5
 * static  MAX_PRIORITY=10   NORM_PRIORITY=5  MIN_PRIORITY=1 */
public class Demo04Priority {

	public static void main(String[] args) {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				for(int i=0;i<200;i++) {
					System.out.println("======"+i);
				}
			}
		};
		t1.setPriority(Thread.MAX_PRIORITY);
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				for(int i=0;i<200;i++) {
					System.out.println("####"+i);
				}
			}
		};
		t2.setPriority(Thread.NORM_PRIORITY);
		
		Thread t3 = new Thread() {
			@Override
			public void run() {
				for(int i=0;i<200;i++) {
					System.out.println("****"+i);
				}
			}
		};
		t3.setPriority(Thread.MIN_PRIORITY);
		t1.start();
		t2.start();
		t3.start();
	}

}