【线程2】Thread的方法

Thread的常用方法

(1).start():启动线程并执行相应的run()方法

(2).run():子线程要执行的代码放入run()方法中

(3).currentThread():静态的，调取当前的线程

(4).getName()：获取此线程的名字

(5)setName():设置此线程的名字

//1.创建一个继承Thread类的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法，方法内实现此子线程要完成的功能
	public void run(){
		for(int i=0;i<=100;i++){
			//调取当前线程，并获取线程的名字
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}
public class TestThread extends Thread {
public static void main(String[] args) {
	//3.创建一个子类的对象
	SubThread st=new SubThread();
	//设置线程st的名字
	st.setName("子线程1");
	//4.调用线程的start（）方法：启动此线程；调用相应的run()方法
	st.start();
	//设置当前线程的名字
	Thread.currentThread().setName("=====主线程");
	for(int i=0;i<=100;i++){
		System.out.println(Thread.currentThread().getName()+":"+i);
	}
}
}

执行结果：

(6).yield():调用此方法的线程释放当前CPU的执行权，释放CPU的执行权后有可能当前线程再次抢到执行权，正常现象

//1.创建一个继承Thread类的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法，方法内实现此子线程要完成的功能
	public void run(){
		for(int i=0;i<=100;i++){
			//调取当前线程，并获取线程的名字
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}
public class TestThread extends Thread {
public static void main(String[] args) {
	//3.创建一个子类的对象
	SubThread st=new SubThread();
	//设置线程st的名字
	st.setName("子线程1");
	//4.调用线程的start（）方法：启动此线程；调用相应的run()方法
	st.start();
	//设置当前线程的名字
	Thread.currentThread().setName("=====主线程");
	for(int i=0;i<=100;i++){
		System.out.println(Thread.currentThread().getName()+":"+i);
		if(i%10==0){
//当前线程释放CPU的执行权
			Thread.currentThread().yield();
		}
	}
}
}

执行结果：

(7).join():在A线程中调用B线程的join()方法，表示：当执行到此方法时，A线程停止执行，直至B线程执行完毕，A线程再接着join()之后的代码执行。

//子线程
//1.创建一个继承Thread类的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法，方法内实现此子线程要完成的功能
	public void run(){
		for(int i=0;i<=100;i++){
			//调取当前线程，并获取线程的名字
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}
//主线程
public class TestThread extends Thread {
public static void main(String[] args) {
	//3.创建一个子类的对象
	SubThread st=new SubThread();
	//设置线程st的名字
	st.setName("子线程1");
	//4.调用线程的start（）方法：启动此线程；调用相应的run()方法
	st.start();
	//设置当前线程的名字
	Thread.currentThread().setName("=====主线程");
	for(int i=0;i<=100;i++){
		System.out.println(Thread.currentThread().getName()+":"+i);
		//在主线程中执行子线程的join()方法，当主线程的i=20时·，执行子线程，子线全部执行完毕执行主线程
		if(i==20){
			try {
				st.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
}

执行结果：

(8).isAlive()：判断当前线程是否还存活，返回一个布尔类型的值。存活返回true，不存活返回false。

//1.创建一个继承Thread类的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法，方法内实现此子线程要完成的功能
	public void run(){
		for(int i=0;i<=100;i++){
			//调取当前线程，并获取线程的名字
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}
//主线程
public class TestThread extends Thread {
public static void main(String[] args) {
	//3.创建一个子类的对象
	SubThread st=new SubThread();
	//设置线程st的名字
	st.setName("子线程1");
	//4.调用线程的start（）方法：启动此线程；调用相应的run()方法
	st.start();
	//设置当前线程的名字
	Thread.currentThread().setName("=====主线程");
	for(int i=0;i<=100;i++){
		System.out.println(Thread.currentThread().getName()+":"+i);
		//在主线程中执行子线程的join()方法，当主线程的i=20时·，执行子线程
		//子线全部执行完毕执行主线程
		if(i==20){
			try {
				st.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	//判断子线程st是否还存活
	System.out.println(st.isAlive());
}
}

9执行结果：

(9).sleep(long l):显式的让当前线程睡眠l毫秒

• 可以调用Thread的静态方法：public static void sleep（long millis）throws InterruptedException   使得当前线程休眠（暂时停止执行millis毫秒）
• 由于是静态方法，sleep可以由类名直接调用：
• Thread.sleep(...)

(10)线程的调度

调度策略：

1.时间片：让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片

2.抢占式：高优先级别的线程抢占CPU

java虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。处于运行状态的线程会一直运行，直至它不得不放弃CPU。

进程的优先级

进程的优先级一共有十个级别，10是最高级别，1是最低级别

其中：MAX_PRIORITY（10）：最高优先级

          MIN_PRIORITY（1）：最低优先级

          NORM_PRIORITY（5）：普通优先级，一般默认优先级为5

涉及的方法：

getPriority:返回线程的优先值

setPriority（int newPriority）：改变线程的优先级

线程创建是可继承父线程的优先值

//1.创建一个继承Thread类的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法，方法内实现此子线程要完成的功能
	public void run(){
		for(int i=0;i<=100;i++){
			//调取当前线程，并获取线程的名字,获取当前线程的优先值
			System.out.println(Thread.currentThread().getName()+":"
			+Thread.currentThread().getPriority()+":"+i);
		}
	}
}
//主线程
public class TestThread extends Thread {
public static void main(String[] args) {
	//3.创建一个子类的对象
	SubThread st=new SubThread();
	//设置线程st的名字
	st.setName("子线程1");
	//设置线程的优先级
	st.setPriority(MAX_PRIORITY);
	//4.调用线程的start（）方法：启动此线程；调用相应的run()方法
	st.start();
	//设置当前线程的名字
	Thread.currentThread().setName("=====主线程");
	for(int i=0;i<=100;i++){
		System.out.println(Thread.currentThread().getName()+":"
				+Thread.currentThread().getPriority()+":"+i);
		
	}
	
}
}

并不是说线程的优先级越高越先执行，而是优先级越高的线程执行的几率比较大，也有优先级较低的线程先执行。