目录
一、梦开始的地方
1、一个进程至少包含一个或多个线程。
2、只有第一个线程启动的时候，开销是比较大的，后续的线程消耗不大。
3、同一个进程里的线程之间，共用了进程的同一份资源（主要指的是内存和文件描述符表）。
共用内存指的是，在线程1中new的一个对象，在其他线程中都可以直接使用。
共用文件描述符表，指的是线程1打开的文件，在其他线程中都可以直接使用。
4、每个线程都有自己的PCB，PCB包含状态，上下文，优先级，记账信息。
所以一个进程可能对应了一个或者多个PCB，但是同一个进程里的PCB之间，pid是一样的，内存指针和文件描述符表也是一样的。
5、线程如果太多，由于核心数目有限，不少的开销反而会浪费在线程调度上。
6、如果一个线程抛异常，如若处理不好，可能把其他线程也带走了。
二、Thread类
1、方法
Thread() //创建线程对象
Thread(Runnable target) //使用Runnable对象创建线程对象
Thread(String name) //创建线程对象，并命名
Thread(Runnable target,String name) //使用Runnable对象创建线程对象，并命名2、常见属性
| 属性 | 获取方法 |
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否后台线程（守护线程） | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
isDaemon()相关：
前台线程，会阻止进程结束。前台线程的工作没干完，进程无法结束。
后台线程，不会组织进程结束。后台线程的工作没做完，进程也是可以结束的。
代码里手动创建的线程，默认都是前台的（包括main默认也是前台的）。
其他的JVM自带的线程是后台的。
也可以手动的使用setDaemon设置成后台线程。
是后台线程，则是守护线程。
isAlive()相关：
在真正调用start之前，调用t.isAlive就是false。调用start之后，isAlive就是true。
isAlive是在判断，当前系统里面的这个线程是不是真的有了。
如果内核里线程把run执行完了，此时线程被销毁，pcb随之释放，但是此时Thread t这个对象不一定会被释放，还存在。所以，此时的isAlive也是false。
三、线程的创建(五种方法)
java中创建线程的写法
1.继承Thread，重写run方法
2、实现Runnable接口
3.使用匿名内部类，继承Thread
4、使用匿名内部类，实现Runnable
5.使用Lambda表达式
1、继承Thread，重写run方法
单线程
//1.继承Thread，重写run方法
//只执行一个子进程
class MyThread1 extends Thread{
@Override
public void run(){
System.out.println("hello world");
}
}
public class ThreadDemo1 {
public static void main(String[] args){
//使用Thread类不用导包,因为在java.lang包下，默认导入了
Thread t= new MyThread1();//创建了一个线程实例,父类引用指向子类实例
t.start();//是Thread类中的一个方法，start创建了一个线程，由新的线程来执行run方法
//创建过程就是，调用操作系统的API，通过操作系统内核创建新进线程的PCB，并且把要执行的指令交给这个PCB，当PCB被调度到CPU上执行时，也就开始执行新线程中run方法里的代码了
}
}
多线程
//两个线程一起执行，并发
class MyThread2 extends Thread{
@Override
public void run(){
while(true){
System.out.println("hello thread");
//为了方便观察，加个sleep函数，但是使用sleep会抛出异常
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class ThreadDemo2 {
public static void main(String[] args){
//使用Thread类不用导包,因为在java.lang包下，默认导入了
Thread t= new MyThread2();//new了一个线程实例,父类引用指向子类实例
t.start();//是Thread类中的一个方法，start创建了一个线程，由新的线程来执行run方法
//创建过程就是，调用操作系统的API，通过操作系统内核创建新进线程的PCB，并且把要执行的指令交给这个PCB，当PCB被调度到CPU上执行时，也就开始执行新线程中run方法里的代码了
//t.start()创建进程之后，会自动销毁进程，如果写成t.run()则会一直卡在上面的进程里出不来
while(true){
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
2、实现Runnable接口
//2、实现Runnable接口
//Runnable的作用，描述一个“要执行的任务”，run方法是任务的执行细节
//好处是解耦合，让线程和线程之间要干的活分开，方便改代码
class MyRunnable implements Runnable{
@Override
public void run(){
System.out.println("hello thread");
}
}
public class ThreadDemo3 {
public static void main(String[] args) {
//先描述任务
Runnable runnable= new MyRunnable();//接口不能被实例化
//把任务交给线程执行
Thread t=new Thread(runnable);
t.start();
}
}
3、使用匿名内部类，继承Thread
//3.使用匿名内部类，继承Thread
//创建了一个Thread的子类（子类没有名字）
//创建了子类的实例，并且让t引用指向该实例
public class ThreadDemo4 {
public static void main(String[] args) {
Thread t=new Thread(){
@Override
public void run(){
System.out.println("hello");
}
};
t.start();
}
}
4、使用匿名内部类，实现Runnable
//4、使用匿名内部类，实现Runnable
//创建了一个类，实现Runnable接口，同时创建了类的实例，并且传给Thread的构造方法
public class ThreadDemo5 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
t.start();
}
}
5、使用Lambda表达式
//5.使用Lambda表达式
public class ThreadDemo6 {
public static void main(String[] args) {
Thread t=new Thread(()->{
System.out.println("hello");
});
t.start();
}
}
四、线程的中断（两种方式）
1、使用标志位，控制线程是否要停止
//线程的中断
//1、使用标志位，控制线程是否要停止
public class ThreadDemo7 {
private static boolean flag=true;
public static void main(String[] args) {
Thread t=new Thread(()->{
while(flag) {
System.out.println("hello world");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
//在主线程里可以通过改变flag变量的取值，来操作t线程是否结束。
flag=false;
}
}2、使用Thread自带的标志位，来进行判定
为true表示被终止，为false表示未被终止（应该要继续走）。
//2、使用Thread自带的标志位，来进行判定
//为true表示被终止，为false表示未被终止（应该要继续走）。
public class ThreadDemo8 {
public static void main(String[] args) {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
//Thread.currentThread(),这是Thread类的静态方法。通过这个方法可以获取到当前线程，哪个线程调用的这个方法，就是得到哪个线程的引用，类似于this
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
t.interrupt();
//interrupt会做两件事：
//1.把线程内部的标志位(boolean)给设置成true
//2.如果线程在进行sleep，就会触发异常，把sleep唤醒
//3.sleep在唤醒的时候，还会把刚才设置的这个标志位再设置回false(清空标志位)
}
}五、线程的等待
join方法有三种形式
1.public void join() //无参数版本，“死等”，不见不散
2.public void join(long millis) //指定一个超时时间（最大等待时间），最为常见
3.public void join(long millis,int nanos) //millis毫秒，nanos纳秒
public class ThreadDemo9 {
public static void main(String[] args) {
Thread t = new Thread(()->{
for(int i=0;i<3;i++){
System.out.println("hello world");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
System.out.println("join之前");
//此处的join就是让当前的main线程来等待t线程执行结束（等待t的run执行完）
//一直阻塞到，t线程执行结束，main线程才会从join中恢复回来，才能继续往下执行。
//t线程比main先结束
try {
t.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("join之后");
}
}
//join方法有三种形式
//1.public void join() //无参数版本，“死等”，不见不散
//2.public void join(long millis) //指定一个超时时间（最大等待时间），最为常见
//3.public void join(long millis,int nanos) //
六、获取当前线程引用
public static Thread currentThread(); //返回当前线程对象的引用
//是一个静态方法，可以直接通过类名调用七、休眠当前线程
public static void sleep(long millis)
//让线程休眠，本质上就是让这个线程不参与调度了。（不去CPU上执行了）
八、线程的状态（六种状态）
| NEW | 初始 | 创建了Thread对象，但是还没调用start（内核里还没创建对应PCB）。 |
| TERMINATED | 终止 | 表示内核中的PCB已经执行完毕了，但是Thread对象还在。 |
| RUNNABLE | 运行 | 包含两种： 1、正在CPU上运行的。 2、在就绪队列里，随时可以去CPU执行的。 |
| WAITING | 等待 | |
| TIMED_WAITING | 超时等待 | |
| BLOCKED | 阻塞 |
387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
