【Java并发编程】Java多线程（一）：线程基础

1.线程介绍

1.1 线程状态

• NEW（创建）：线程刚被创建，但未启动，还未调用start
• RUNNABLE（可运行）：调用了 strat 方法；可能在CPU执行，也有可能没有
• TIMED_WAITING（计时等待）：让出CPU，计时休眠；sleep（持锁）
• WAITINIT（等待）：让出CPU，休眠；无锁park->unpark，有锁wait->notify（会释放锁）
• BLOCKED（阻塞）：等待获得 monitor lock 锁，是对于 synchronized 而言
• TERMINATED（终止）：运行结束；子线程运行完成、被打断、被中止

下图是进程状态与Java线程状态对比：

1.2 优先级

优先级代表线程执行的机会的大小，优先级高的可能先执行，低的可能后执行，在 Java 源码中，优先级从低到高分别是 1 到 10，线程默认 new 出来的优先级都是 5，源码如下：

// 最低优先级
public final static int MIN_PRIORITY = 1; 

// 普通优先级，也是默认的
public final static int NORM_PRIORITY = 5;

// 最大优先级
public final static int MAX_PRIORITY = 10;

1.3 守护线程

我们默认创建的线程都是非守护线程。创建守护线程时，需要将 Thread 的 daemon 属性设置成 true，守护线程的优先级很低，当 JVM 退出时，是不关心有无守护线程的，即使还有很多守护线程，JVM 仍然会退出，我们在工作中，可能会写一些工具做一些监控的工作，这时我们都是用守护子线程去做，这样即使监控抛出异常，但因为是子线程，所以也不会影响到业务主线程，因为是守护线程，所以 JVM 也无需关注监控是否正在运行，该退出就退出，所以对业务不会产生任何影响。

1.4 几点注意

• 线程是交替运行的（任务>时间片），现在CPU往往多核
• main是主线程，可能提前执行完成一般不要阻塞
• 线程间相互独立，当有异常抛出时，只会影响当前线程
• Thread.currentThread()当前线程

2.*线程创建 & 运行

**线程相当于载体，要start必须要有任务(Callable/Runnable) **

2.1 Thread

为了方便，Thread已经实现了Runnable，因此可以直接继承Thread，并重写run方法

class MyThread extends Thread{
    
    
  public void run() {
    
    ...}
}

2.2 Runnable

// 内部类
Thread thread = new Thread(new Runnable() {
    
    
  public void run() {
    
    ...}
});

// lamada
new Thread(()->{
    
    
    public void run() {
    
    ...}
}).start()

2.3 Callable

// Callable不能直接使用，而是包装成FutureTask 
FutureTask futureTask = new FutureTask(new Callable<T> () {
    
    
    public String call() throws Exception {
    
    ...}
  });
// FutureTask也是Runnable，所以可以传入Thread然后运行
new Thread(futureTask).start();
// 获取执行结果，无参会一直阻塞等待执行结果
futureTask.get()

-> start方法源码

start 方法可以创建一个新的线程出来，内部就是调用Runnable的run方法

public synchronized void start() {
    
    
    // 如果没有初始化，抛异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    // started 是个标识符，我们在做一些事情的时候，经常这么写
    // 动作发生之前标识符是 false，发生完成之后变成 true
    boolean started = false;
    try {
    
    
        // 这里会创建一个新的线程，执行完成之后，新的线程已经在运行了，既 target 的内容已经在运行了
        start0();
        // 这里执行的还是主线程
        started = true;
    } finally {
    
    
        try {
    
    
            // 如果失败，把线程从线程组中删除
            if (!started) {
    
    
                group.threadStartFailed(this);
            }
         // Throwable 可以捕捉一些 Exception 捕捉不到的异常，比如说子线程抛出的异常
        } catch (Throwable ignore) {
    
    
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}
// 开启新线程使用的是 native 方法
private native void start0();

3.线程控制

3.1 Thread.sleep

• 线程进入Timed_Waiting，当前线程休眠，释放CPU，持锁等待
• 作用
  • 模拟任务；防止多线程下任务<时间片，线程串行执行
  • 暂停线程；在线程运行期间将其暂停，让其余线程运行
• TimeUnit.SECONDS.sleep(2)

3.2 Thread.yeild

• 当前线程让出CPU，进入NEW状态，再次去竞争CPU
• 作用：防止当前线程一直占用CPU
• 与sleep的区别
  • sleep可以指定等待时间
  • sleep这段时间各个级别的线程都可运行，yeild一般只能让优先级高的线程运行

3.3 Thread.interrput

• 设置线程中断不影响线程的继续执行
• 但是线程设置休眠后（wait、jion、sleep）， 抛出 InterruptedException，且中断标志被清除，重新设置为false
• Thread.currentThread().isInterrupted()

3.4 obj.wait

• 线程进入WAITING，释放当前对象的锁，等待被唤醒
• 必须在synchronized代码块内使用，要先持有锁
  • 本质：Java的线程通信实质上是共享内存，而不是直接通信
  • 表象：wait,notify需要调用monitor对象
• 一般配合while使用
  • 被唤醒后会重新竞争锁，之后从上次wait位置重新运行
  • while多次判断，防止在wait这段时间内对象被修改

3.5 obj.notify(All)

• 随机唤醒wait的线程
• 必须在synchronized代码块中使用
• 等当前线程运行完释放锁后，唤醒的线程再重新竞争锁
• 在生产者消费者模型中，推荐使用notifyAll，因为notify唤醒的线程不确定是生产者或消费者

3.6 obj.join

• 当前线程会等待调用join的线程结束后，再继续运行
• 本质：其实就是当前线程功能wait，调用线程运行完后notify
• 作用
  • 当线程任务量大时，保证main线程在这些线程运行结束后再结束、
  • 可控制子线程间执行顺序

3.7 LockSupport.park

• 使指定线程在没获得锁的情况下进入WAITING，休眠释放CPU
• 需要unpark指定唤醒线程
• 区别对比：
  • wait：unpark(th)可以唤醒指定线程，而notify是随机唤醒
  • yeild：park进入休眠状态不再抢占CPU，而yeild只是让出并参与下一次CPU竞争
  • interrput：interrput在线程休眠前不会影响线程执行
• park是定义UNSAFE中的，一般通过LockSupport调用