线程1——javaEE 附面题

PID	同一台机器，同一时间，不重复
内容指针	内存资源分为数据/指令操作系统可通过其找到数据/指令
文件描述符表	硬盘资源打开文件可以得到一个文件描述符，打开多个就可以用数组/顺序表表示
状态	就绪状态 / 阻塞状态
优先级	依据重要性给进程分配资源
上下文	进程调度出 cpu 时保存一个中间状态，保证进程再调度回来时可以恢复之前的工作
记账信息	PCB 会记录下进程在CPU上执行的次数，分配写资源给使用资源少的进程

进程的创建/销毁开销（销毁时间和系统资源）非常大，在创建时申请资源（大开销操作），为了提高效率降低开销引入了线程。

进程和线程的关系

1.线程是更轻量的进程。（进程太重了大开销，低效率）
2.进程包含线程，一个线程有大于等于一个线程，不能没有。
3.同一个进程上的线程共享进程的资源。
4.每个线程都可以执行独立的逻辑，并在cpu上独立调度
5.当进程已经有了，在进程上创建线程可以省去申请资源的开销。

线程

线程是系统调度执行的基本单位。
线程满足了“并发编程” 使一个服务器可以同时处理多个客户端的访问。

线程虽更轻量，多线程可以提升效率，但过犹不及。
线程过多带来的问题：
1.线程过多时，线程的创建和销毁时的开销就不可忽视了。
2.多线程环境下，多个线程对同一个变量同时进行操作。
多对一可读不可取
一对一可读又可取

3.线程中断会抛出异常，如果没有被捕获到，进程就会崩溃，线程会全挂掉。

创建线程

1.通过创建 Thread 子类

重写 run(); 方法，创建Thread 对象，调用start();

代码实现：

class myThread extends Thread{
    public void run (){
        System.out.println("hello thread");
    }
}
public class demo1 {


    public static void main(String[] args) {
         Thread thread = new myThread();
         thread.start();
        System.out.println("hello main");


    }
}

👀输出：

通过写入无限循环观察下：

代码：

class myThread extends Thread{
        @Override
        public void run() {
            while(true){
                try {
                    System.out.println("hello thread");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }



public class demo1 {

    public static void main(String[] args) {
        Thread thread = new myThread();
        thread.start();
        
        while(true){
            try {
                System.out.println("hello main");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

👀输出

观察结果可以发现 main 主线程和我们自己创建的 thread 线程是并行执行的，顺序由cpu调度决定，随机出现。

2.通过实现 Runnable接口

再将 runnable 实例作为参数传给Thread 构造方法

代码：

class myRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello thread");

    }
}    
public class demo2 {
    public static void main(String[] args) {
        Runnable runnable = new myRunnable(); 
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println("hello main");
    }
}

👀输出：

这样的写法分离了任务逻辑和线程管理，不依赖于具体的类，使得后续可以轻松替换任务实现，降低程序的耦合度。

3.子类匿名表达式

代码： Thread t = new Thread () {

public void run(){

}

}；

public class demo3 {

    public static void main(String[] args) {
        // 匿名内部类 是Thread的子类 重写了run方法
        Thread t = new Thread(){
            public void run(){
                while(true){
                    try {
                        System.out.println("hello thread");
                        Thread.sleep(1000);  //  休眠1000ms  降低打印速度方便观察
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
        System.out.println("hello main");
    }

}

👀输出：

4.匿名内部类（Runnable）

代码：

Runnable runnable = new Runnable({

});

Thread t = new Thread(runnable);

public class demo4 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                while(true){
                    try {
                        System.out.println("hello thread");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }; 
        Thread t = new Thread(runnable);
        t.start();

        while(true){
            try {
                System.out.println("hello main");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

👀输出：

启动线程

Thread.start(); start() 是 Thread 类的一个静态方法，可以直接用类名调用。

1.调用 start 会真正调用系统中创建线程的 api start 执行不会产生阻塞，按代码顺序立刻向下执行。

2.一个线程只能 start 一次。 start 后线程要么是就绪，要么是阻塞不能重新启动了。

3.start 执行会自动执行 run() 方法。

Thread 类的常用属性（方法）

方法类别	方法名	功能描述	补充说明
ID	getId()	获取线程唯一标识符	每个线程都有一个唯一的标识符，由 JVM 分配，从 1 开始递增
名称	getName()	获取线程名称	线程创建时可以指定名称
状态	getState()	获取线程状态	返回线程当前状态（NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED）
优先级	getPriority()	获取线程优先级	线程优先级设置效果受操作系统调度机制影响，"改了不一定有用"，
守护线程	isDaemon()	判断是否为守护线程	守护线程会在所有非守护线程结束后自动终止，主要用于后台支持任务
存活状态	isAlive()	判断线程是否存活	返回 false 表示线程未启动（NEW 状态）或已结束（TERMINATED 状态）
中断状态	isInterrupted()	判断线程是否被中断	不会清除中断标记，需要通过 Thread.interrupted () 静态方法清除中断标记

注：isDaemon() 是否为后台线程
后台线程：当线程没执行完时，进程要结束，线程无法阻止当前进程结束。
前台线程：当前线程没执行完，进程要结束要等线程执行完，这样的线程成为前台线程。

线程的状态

New	创建了线程对象但还没start isAlive false
TERMINED	执行完成了（run完了）但对象还在 isAlive false
WAITING	死等 join 无参未设置超时时间
TIME_WAITING	有时间的等 join 设置了超时时间
BLOCKED	锁竞争产生的阻塞

线程休眠

sleep(时间 ms) Thread 类的静态方法让线程休眠多少毫秒后（进入Time_WAITING）
sleep 线程进入阻塞，调度出CPU ，唤醒后变为就绪状态，但不会立即执行，等待CPU调度。

打断线程

希望线程提前结束（sleep 时提前唤醒）

1.通过变量修改

2.通过 isInterrupted 标志位

查看当前中断状态：Thread.currentThread().isInterrupted() 不清除中断标志
检查中断状态：Thread.interrupted() 清除中断标志

若线程处于休眠sleep，会抛出InterruptedException 异常，需要 catch
try{
  Thread.sleep(1000);
}catch (InterruptedException e) {
  Thread.currentThread.interrupt();
}

线程等待 join

控制线程之间的执行顺序。

有两个版本的join
1.join()；死等
2.join(超时时间) 等待到超时时间后就不等了

线程 t1 线程t2
t1.join(); t2等t1执行完
t1.join(1000) t2等待t1执行完，等了1000ms t1还没结束就不等了

⭐谁调用谁被等

线程安全问题

why:❓❓❓
1. 【根本原因】操作系统的随即调度，抢占式执行。
2. 操作不是原子的。（原子的：不可再分的最小操作）
3. 多个变量同时操作同一个变量。
4. 内容不可见
5. 指令重排序

        面对非原子的操作，多线程就会出现多线程做同一个操作但做的是这个操作的不同部分
怎么理解呢？就好像把一个大象放进冰箱需要几步。（这就是非原子操作是可拆分的）
1.打开冰箱门
2.把大象放进去
3.关上冰箱门
        这时候如果有多个线程同时进行把同一只大象放进冰箱的操作。就有可能线程一打开了冰箱门被调度出CPU，线程2也执行了打开冰箱门，重复开门冰箱们受不了，线程2把大象放进冰箱并关上了冰箱门然后被调度出CPU，线程一被调度回CPU读取了中间状态继续之前的操作，把大象放进去，关上冰箱门。

        把一只大象放进去了两遍也就是BUG出现了，有人要问最后不还是大象在冰箱里面吗，但无效的操作消耗了资源，在这虽然没造成什么严重后果但这要是转账操作呢，同时扣了两次款呢？

how:
那怎么保证安全呢？
既然是非原子操作造成的那可以把操作打包成原子的，java中提供了synchronized 可以给操作加锁保证线程一次把该执行完的逻辑执行完，这时有其他线程来执行这个操作就会触发锁竞争，产生阻塞等待上一个执行此操作的线程执行完解锁才能拿到锁，开始执行该操作。

锁synchronized()

先从使用入手

synchronized 有两个大括号
进入第一个大括号表示锁已经加上了，
从第二个大括号出来就表示解锁了。

通过加锁操作可以把操作变成原子的。

原理：加同一把锁的线程（锁对象是相同的）会竞争同一把锁（锁竞争）没抢到的阻塞等待抢到的解锁再抢。

锁对象 Object locker = new Object();

1.锁

synchronized(锁对象){
      // 操作

}

2.修饰普通方法

synchronized public void 方法（）{

//     this是锁对象

}

3.修饰静态方法

synchronized public static void 方法（）{
          // static 没有this ,所以锁对象是类对象
          // 类对象 .class
}

特性

1.互斥

当一个线程已经拥有锁的时候，该线程的锁不能被抢占。

2.可重入

当一个线程已经拥有一把锁的情况下，对于已有的这把锁可以重复加锁多次（连续加同一把锁）且不会触发死锁。

wait/notify

Object类的方法

协调线程之间执行的顺序区别 join 控制线程间结束顺序

wait 会使线程释放锁主动阻塞等待，直到被notify 唤醒
eg:
希望t1先执行再让t2执行
使用wait主动让t2阻塞让t1先参与调度，等t1执行完用notify唤醒t2.

使用

Object object = new Object ();
object.wait(); // wait() 会阻塞可能会抛出 InterruptedException 当执行wait时其内部会第一时间把锁放了

放锁的前提得先有一把锁，wait放锁后当前线程就会进入阻塞状态 WAITING ,等待被唤醒，被唤醒后会再重新尝试去获取之前的锁，就会引发锁竞争 BLOCKED (被唤醒了，等拿到锁就会继续执行)

所以wait 应该搭配synchronized使用

wait使用

Object object = new Object();
try{
    synchronized(object){
    object.wait();
    }
}catch(InterruptedExecption e){

两者搭配

创建两个线程，线程t1等待，线程t2来唤醒t1

import java.util.Scanner;

public class demo_notify {

    public static Object locker = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("t1 等待");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1 等待后");
        });


        Thread t2 = new Thread(() -> {
            System.out.println("请输入任意内容唤醒t1");
            Scanner scanner = new Scanner(System.in);
            scanner.next();
            synchronized (locker) { 
                locker.notify();
            }
        });


        t1.start();
        t2.start(); 

    }

}

👀输出

当多个线程都在 wait 时（同一个对象），此时 notify 会随机唤醒一个。使用 notifyAll 可以唤醒所有的。

import java.util.Scanner;

public class demo_notifyAll {

    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("t1 等待前");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1 等待后");
        });

    Thread t2 = new Thread(() -> {
        System.out.println("t2 等待前");
        synchronized (locker) {
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("t2 等待后");
    });

    Thread t3 = new Thread(() -> {
        System.out.println("请输入任意内容唤醒t1或t2");
        Scanner scanner = new Scanner(System.in);
        scanner.next();
        synchronized (locker) {
            locker.notify();
        }
    });

    t1.start();
    t2.start();
    t3.start();

    }

}

输出：此时t3只会唤醒t1或t2其中一个。我这里运行唤醒了t2

想同时唤醒t1,t2就需要用notifyAll

import java.util.Scanner;

public class demo_notifyAll {

    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("t1 等待前");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1 等待后");
        });

    Thread t2 = new Thread(() -> {
        System.out.println("t2 等待前");
        synchronized (locker) {
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("t2 等待后");
    });

    Thread t3 = new Thread(() -> {
        System.out.println("请输入任意内容唤醒t1或t2");
        Scanner scanner = new Scanner(System.in);
        scanner.next();
        synchronized (locker) {
            locker.notifyAll();
        }
    });

    t1.start();
    t2.start();
    t3.start();

    }

}

输出：

面经：

谈谈sleep 和 wait 的区别。
答：
1.wait 的设计是为了提前唤醒，超时时间只是作为Plan B。
sleep 的设计就是为了到时间唤醒，虽可用 interrupt 提前唤醒但这样的唤醒会产生异常。

2.wait 需要搭配锁使用，因为执行时会先释放锁。（避免其他线程一直拿不到锁）
sleep 就不需要搭配锁使用，当sleep 被放到synchronized中时，不会释放锁而是抱着锁睡。

多线程实用但充满陷阱未完待续。

爱是个什么东西，它太理想主义，爱有什么了不起，我充满许多怀疑
爱是个什么东西 DT
⭐❤️👍