线程的三种创建方式 和 线程的状态

线程

进程: 一个正在运行的程序 就是一个进程

线程: 一个进程中有很多个线程,每一个线程相当于一个执行的任务

开启一个线程,相当于开启了一个CPU的执行路径(相对独立)

CPU在执行多个线程时 是随机的 跟线程的优先级有关

分时调度---CPU会在对个线程中进行随机切换

主线程

多线程的程序,出了主线程外,一般都是子线程

一个程序只有一个主线程

main函数 就是一个线程,并且是主线程

主线程的执行过程

JVM调用main函数 --> CPU就为main函数开辟一个执行路径 --> 相当于在这个执行路径中 执行main函数中的代码

Thread线程类(开辟一个主线程以外的线程 --- 子线程)

1.创建一个Thread类的子类

2.重写run方法  run方法是线程要执行的代码

3.调用start方法 开启线程(不可重复开启,start只能调用一次)

public class D2线程 {
	public static void main(String[] args) {
		// 子线程
		SubThread subThread = new SubThread();
		subThread.start();
		// 主线程
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName());
		}
	}
}
// 声明线程子类 重写run方法
class SubThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName());
		}
	}
}

注意 : 分时调度---CPU会在对个线程中进行随机切换

运行结果:

main
main
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
main
main
main
main
main
main
main
main

Thread.currentThread().getName  获取当前线程的线程名的方法,没有设置则会按照系统默认名

主线程: 默认名main    子线程: 默认名Thread-x

注意: 运行过程中 一个线程中出现异常 不会影响其他线程的执行(每个线程是相对独立的路径)

线程名的设置

构造子线程时写入构造方法(构造方法不能继承)

调用父类的无参有参构造方法  并对有参构造方法调用父类构造方法,且赋值name

class NameThread extends Thread {
	// 有参构造方法
	public NameThread(String name) {
		// 调用父类的构造方法 赋值name
		super(name);
	}
	// 无参
	public NameThread() {
		
	}
        // 重写run方法
	@Override
	public void run() {
System.out.println("子线程:" + Thread.currentThread().getName());
	}
}

在主函数中运行

public static void main(String[] args) {
		NameThread t1 = new NameThread("哈哈");
		// 设置线程名字
		t1.setName("线程--1");
		// 直接调用run方法
		// 相当于 调用了一个普通的成员方法
		t1.run();
		// 调用start方法 系统会开辟一个线程出来
		t1.start();
		//System.out.println(t1.getName());
		
		// 获取主线程的名字
		// 获取当前正在执行的线程
		Thread currentThread = Thread.currentThread();
		System.out.println(currentThread.getName());
	}

注意: 声明子线程对象  若直接调用run方法,则为调用普通方法,不是开辟线程

也可用get/set方法为子线程设置线程名,但是要注意  写入get/set方法时要重命名方法名

父类中用final修饰了get/set方法 不能被子类所重写,赋值时要取个新名字

class MyThread extends Thread {
	// 定义了自己的name属性(尽量避免重名)
	private String name;
	
	public MyThread() {
		
	}
// 可以修改方法名 重写提供set/get方法
	private void setMyName(String name) {
		this.name = name;
	}
	public String getMyName() {
		return this.name;
	}
	@Override
	public void run() {
		
	}
}

创建线程也相当于开辟了一个独立子线程栈  专门来运行子线程中的方法

所以main函数运行时出现分时调度,而不是栈的先进后出

匿名内部类

利用匿名内部类的方法,给集合中 3个学生对象 按年龄进行排序(使用比较器)

// 创建匿名内部类
public static void main(String[] args) {
    Comparator<Student> comparator = new Comparator<Student>() {
	   @Override
	   public int compare(Student o1, Student o2) {
		int num = o1.getAge() - o2.getAge();
		return num;
            }
    };  // 注意此处分号
    // 传入匿名内部类方式创建出来的实现类的对象
    TreeSet<Student> set = new TreeSet<>(comparator);
    set.add(new Student("A", 13));
    set.add(new Student("B", 15));
    set.add(new Student("C", 14));
    System.out.println(set);

将上面代码合写

TreeSet<Student> set2 = new TreeSet<>(new Comparator<Student>() {
	@Override
	public int compare(Student o1, Student o2) {
		int num = o1.getAge() - o2.getAge();
		return num;
	}
});

线程的三种创建方式

// 方式一(用Thread子类的方式)
Thread thread = new Thread() {
	@Override
	public void run() {
		System.out.println("子线程执行的方法");
	}
};
thread.start();

// 方式二(用接口实现类的方式)
Runnable runnable = new Runnable() {
	@Override
	public void run() {
		System.out.println("子线程的方法");
	}
};
Thread t2 = new Thread(runnable);
t2.start();

// 方式三(方式二的两步写一起)
new Thread(new Runnable() {
	@Override
	public void run() {
		System.out.println("子线程的方法");
	}
}).start();

线程的6种状态

1.新建状态(new Thread)

2.运行状态(start())

3.死亡状态(run方法运行完毕)

4.受阻塞状态(CPU未执行该线程时)

5.休眠状态(sleep方法 休眠时间过了 恢复)

6.等待状态(wait notify)

休眠方法

Thread.sleep(1000);  // 睡眠1秒后再继续执行下面代码

休眠时间结束 会自动醒来

参数是时间 单位:毫秒

子线程设置休眠时需要解决异常  

注意:  父类run方法没有抛异常,子类run方法不能抛异常,只能try--catch处理

class TeseA extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			// 休眠
			// 父类中的run方法没抛异常 
			// 子类只能try---catch处理
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		}
	}
}

线程调用了start()方法不一定就会变为运行状态,只是表示该方法可以被CPU执行

但是cpu不一定来执行这个线程,所以不一定变成运行状态

需要等待cpu执行    这时的状态就是受阻状态