JUC笔记-线程

---

一、进程线程、并行并发、同步异步概念

1.1 进程与线程

• 进程: 资源分配的最小单位
  进程是线程的容器，一个进程中包含多个线程，真正执行任务的是线程。

• 线程: 资源调度的最小单位
  线程是属于进程的，是一个基本的 CPU 执行单元，是程序执行流的最小单元。线程本身不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。

线程的作用：使多道程序更好的并发执行，提高资源利用率和系统吞吐量，增强操作系统的并发性能。

二者对比

• 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
• 进程拥有共享的资源，如内存空间等，供其内部的线程共享;
• 进程间通信较为复杂
  • 同一台计算机的进程通信称为 IPC（Inter-process communication）
  • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
• 线程通信相对简单，因为它们共享进程内的内存，多个线程可以访问同一个共享变量
  • Java 中的通信机制：volatile、等待/通知机制、join 方式、InheritableThreadLocal、MappedByteBuffer
• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

1.2 并发与并行

• 并发：在同一时刻，有多个指令在单个 CPU 上交替执行
• 并行：在同一时刻，有多个指令在多个 CPU上同时执行

1.3 同步与异步

• 需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就是异步

二、线程的创建（重点）

2.1 通过继承Thread创建线程

Thread 创建线程方式：创建线程类，匿名内部类方式

• start() 方法底层其实是给 CPU 注册当前线程，并且触发 run() 方法执行
• 线程的启动必须调用 start() 方法，如果线程直接调用 run() 方法，相当于变成了普通类的执行，此时主线程将只有执行该线程

Thread 构造器：

• public Thread()
• public Thread(String name)

public class CreateThread {
	public static void main(String[] args) {
		Thread myThread = new MyThread();
        // 启动线程
		myThread.start();
	}
}

class MyThread extends Thread {
	@Override
	public void run() {
		System.out.println("my thread running...");
	}
}

继承 Thread 类的优缺点：

• 优点：
  编码简单，在run()方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread()方法
• 缺点：
  线程类已经继承了 Thread 类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）

2.1 使用Runnable配合Thread (推荐)

Runnable 创建线程方式：创建线程类，匿名内部类方式

Thread 的构造器：

• public Thread(Runnable target)
• public Thread(Runnable target, String name)

public class Test2 {
	public static void main(String[] args) {
		//创建线程任务
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println("Runnable running");
			}
		};
		//将Runnable对象传给Thread
		Thread t = new Thread(r);
		//启动线程
		t.start();
	}
}

或者

public class CreateThread2 {
   private static class MyRunnable implements Runnable {
      @Override
      public void run() {
         System.out.println("my runnable running...");
      }
   }

   public static void main(String[] args) {
      MyRunnable myRunnable = new MyRunnable();
      Thread thread = new Thread(myRunnable);
      thread.start();
   }
}

Thread 类本身也是实现了 Runnable 接口，Thread 类中持有 Runnable 的属性，执行线程 run 方法底层是调用 Runnable接口中的run()方法：

Runnable 方式的优缺点：

优点：

• 线程任务类只是实现了 Runnable 接口，可以继续继承其他类，避免了单继承的局限性

• 同一个线程任务对象可以被包装成多个线程对象

• 适合多个线程去共享同一个资源

• 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立

• 线程池可以放入实现 Runnable 或 Callable 线程任务对象

缺点：

• 代码复杂一点。

2.3 使用FutureTask与Thread结合（Callable接口）

实现 Callable 接口：

• 定义一个线程任务类实现 Callable 接口，申明线程执行的结果类型
• 重写线程任务类的 call 方法，这个方法可以直接返回执行的结果
• 创建一个 Callable 的线程任务对象
• 把 Callable 的线程任务对象包装成一个未来任务对象
• 把未来任务对象包装成线程对象
• 调用线程的start() 方法启动线程

public FutureTask(Callable<V> callable)：未来任务对象，在线程执行完后得到线程的执行结果

• FutureTask 就是 Runnable 对象，因为 Thread 类只能执行 Runnable 实例的任务对象，所以把 Callable 包装成未来任务对象
• 线程池部分详解了 FutureTask 的源码

public V get()：同步等待 task 执行完毕的结果，如果在线程中获取另一个线程执行结果，会阻塞等待，用于线程同步

• get() 线程会阻塞等待任务执行完成
• run() 执行完后会把结果设置到 FutureTask 的一个成员变量，get() 线程可以获取到该变量的值

public class ThreadDemo {
    public static void main(String[] args) {
        Callable call = new MyCallable();
        FutureTask<String> task = new FutureTask<>(call);
        Thread t = new Thread(task);
        t.start();
        try {
            String s = task.get(); // 获取call方法返回的结果（正常/异常结果）
            System.out.println(s);
        }  catch (Exception e) {
            e.printStackTrace();
        }
    }

public class MyCallable implements Callable<String> {
	//重写线程任务类方法
    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName() + "->" + "Hello World";
    }
}

或者匿名内部类

public class Test3 {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        //需要传入一个Callable对象
		FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {
			@Override
			public Integer call() throws Exception {
				System.out.println("线程执行!");
				Thread.sleep(1000);
				return 100;
			}
		});

		Thread r1 = new Thread(task, "t2");
		r1.start();
		//获取线程中方法执行后的返回结果
		System.out.println(task.get());
	}
}

优缺点：

• 优点：
  同 Runnable，并且能得到线程执行的结果
• 缺点：
  编码复杂

三、线程运行原理（重点）

3.1 虚拟机栈与栈帧

虚拟机栈描述的是Java方法执行的内存模型。

每个方法被执行的时候都会同时创建一个栈帧(stack frame)用于存储局部变量表、操作数栈、动态链接、方法返回地址等信息，是属于线程私有的。

当Java中使用多线程时，每个线程都会维护它自己的栈帧。每个线程只能有一个活动栈帧(在栈顶)，对应着当前正在执行的那个方法。

3.2 线程上下文切换（Thread Context Switch)

线程上下文切换（Thread Context Switch）：一些原因导致 CPU 不再执行当前线程，转而执行另一个线程。

• 线程的 CPU 时间片用完
• 垃圾回收
• 有更高优先级的线程需要运行
• 线程自己调用了 sleep、yield、wait、join、park 、synchronized、lock等方法

程序计数器（Program Counter Register）：记住下一条 JVM 指令的执行地址，是线程私有的

当 Thread Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等

Java 创建的线程是内核级线程，线程的调度是在内核态运行的，而线程中的代码是在用户态运行，所以线程切换（状态改变）会导致用户与内核态转换，这是非常消耗性能

3.3 线程的常用方法

3.3.1 start 与 run方法的区别

• run：称为线程体，包含了要执行的这个线程的内容，方法运行结束，此线程随即终止。直接调用 run 是在主线程中执行了 run，没有启动新的线程，需要顺序执行

• start：使用 start 是启动新的线程，此线程处于就绪（可运行）状态，通过新的线程间接执行 run 中的代码

面试问题：run() 方法中的异常不能抛出，只能 try/catch

• 因为父类中没有抛出任何异常，子类不能比父类抛出更多的异常
• 异常不能跨线程传播回 main() 中，因此必须在本地进行处理

3.3.2 sleep 与 yield

sleep：

• 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
• sleep() 方法的过程中，线程不会释放对象锁
• 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
• 睡眠结束后的线程未必会立刻得到执行，需要抢占 CPU
• 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield：

• 调用 yield 会让提示线程调度器让出当前线程对 CPU 的使用，会让当前线程从Running 进入 Runnable 就绪状态，然后调度执行其它线程
• 具体的实现依赖于操作系统的任务调度器
• 会放弃 CPU 资源，锁资源不会释放

小结：yield使cpu调用其它线程，但是cpu可能会再分配时间片给该线程；而sleep需要等过了休眠时间之后才有可能被分配cpu时间片

3.3.3 线程优先级

线程优先级会提示调度器优先调度该线程，但这仅仅是一个提示，调度器可以忽略它

如果 CPU 比较忙，那么优先级高的线程会获得更多的时间片，但 CPU 闲时，优先级几乎没作用

3.3.4 join

public final void join()：等待这个线程结束

原理：调用者轮询检查线程 alive 状态，t1.join() 等价于：

public final synchronized void join(long millis) throws InterruptedException {
    // 调用者线程进入 thread 的 waitSet 等待, 直到当前线程运行结束
    while (isAlive()) {
        wait(0);
    }
}

• join 方法是被synchronized修饰的，本质上是一个对象锁，其内部的 wait 方法调用也是释放锁的，但是释放的是当前的线程对象锁，而不是外面的锁

• 当调用某个线程（t1）的 join 方法后，该线程（t1）抢占到 CPU 资源，就不再释放，直到线程执行完毕

private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    },"t1");
    t1.start();
    t1.join(); 
    // 这里如果不加t1.join(), 此时主线程不会等待t1线程给r赋值, 主线程直接就输出r=0结束了
    // 如果加上t1.join(), 此时主线程会等待到t1线程执行完才会继续执行.(同步), 此时r=10;
    log.debug("结果为:{}", r);
    log.debug("结束");
}

3.3.5 interrupt、isInterrupted与interrupted

打断线程

public void interrupt()：打断这个线程，异常处理机制

public boolean isInterrupted()：判断当前线程是否被打断，不清除打断标记

public static boolean interrupted()：判断当前线程是否被打断，打断返回 true，清除打断标记，连续调用两次一定返回 false

打断的线程会发生上下文切换，操作系统会保存线程信息，抢占到 CPU 后会从中断的地方接着运行（打断不是停止）

• sleep、wait、join 方法都会让线程进入阻塞状态，打断进程会清空打断状态（false）

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("sleep...");
            try {
                Thread.sleep(5000); // wait, join
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        Thread.sleep(1000);
        System.out.println("iterrupt..");
        t1.interrupt();
        System.out.println(t1.isInterrupted()); // 如果是打断sleep,wait,join的线程, 标记为false
    }
}

运行结果：

sleep...
iterrupt..
打断标记为:false
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.guizy.ThreadPrintDemo.lambda$main$0(ThreadPrintDemo.java:14)
	at java.lang.Thread.run(Thread.java:748)

Process finished with exit code 0

• 打断正常运行的线程：不会清空打断状态（true）

打断正常运行的线程，线程并不会暂停，只是调用方法Thread.currentThread().isInterrupted()的返回值为true，可以判断Thread.currentThread().isInterrupted()的值来手动停止线程

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        while(true) {
            boolean interrupted = Thread.currentThread().isInterrupted();
            // 通过判断打断标记是否为true来手动停止线程
            if(interrupted) {
                System.out.println("被打断了, 退出循环");
                break;
            }
        }
    }, "t1");
    t1.start();
    Thread.sleep(1000);
    System.out.println("interrupt");
    t1.interrupt();
    System.out.println("打断标记为: " + t1.isInterrupted());
}

执行结果：

interrupt
被打断了, 退出循环
打断标记为: true

Process finished with exit code 0

3.4 终止模式之两阶段终止模式

Two Phase Termination： 当我们在执行线程一时，想要终止线程二，这时就需要使用interrupt方法来优雅的停止线程二。这里的优雅指的是给T2线程一个处理其他事情的机会（如释放锁）。

错误思路：

• 使用线程对象的 stop() 方法停止线程：stop 方法会真正杀死线程，如果这时线程锁住了共享资源，当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
• 使用 System.exit(int) 方法停止线程：目的仅是停止一个线程，但这种做法会让整个程序都停止

两阶段终止模式图示：

打断线程可能在任何时间，所以需要考虑在任何时刻被打断的处理方法：

• 如果线程在睡眠sleep期间被打断，打断标记是不会变的，为false，但是sleep期间被打断会抛出异常，我们据此手动设置打断标记为true；
• 如果是在程序正常运行期间被打断的，那么打断标记就被自动设置为true。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        Thread.sleep(3500);
        tpt.stop();
    }
}
class TwoPhaseTermination {
    private Thread monitor;
    // 启动监控线程
    public void start() {
    	//设置线控器线程，用于监控线程状态
        monitor = new Thread(new Runnable() {
            @Override
            public void run() {
            	//开始不停的监控
                while (true) {
                    Thread thread = Thread.currentThread();
                    // 判断当前线程是否被打断了
                    if (thread.isInterrupted()) {
                        System.out.println("后置处理");
                        //终止线程执行
                        break;
                    }
                    try {
                        Thread.sleep(1000);					// 睡眠
                        System.out.println("执行监控记录");	// 在此被打断不会异常
                    } catch (InterruptedException e) {		// 在睡眠期间被打断，进入异常处理的逻辑
                        e.printStackTrace();
                        // 重新设置打断标记
                        thread.interrupt();
                    }
                }
            }
        });
        monitor.start();
    }
    // 停止监控线程
    public void stop() {
        monitor.interrupt();
    }
}

3.5 sleep，yiled，wait，join 对比

wait/notify 是 object 中的方法

方法	方法说明
sleep	不释放锁、释放cpu
join	释放锁、抢占cpu
yiled	不释放锁、释放cpu
wait	释放锁、释放cpu

不推荐

不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁：

方法	功能
public final void stop()	停止线程运行
public final void suspend()	挂起（暂停）线程运行
public final void resume()	恢复线程运行

3.6 守护线程

当Java进程中有多个线程在执行时，只有当所有非守护线程都执行完毕后，Java进程才会结束。但当非守护线程全部执行完毕后，守护线程无论是否执行完毕，也会一同结束。

public final void setDaemon(boolean on)：如果是 true ，将此线程标记为守护线程

线程启动前调用此方法：

Thread t = new Thread() {
    @Override
    public void run() {
        System.out.println("running");
    }
};
// 设置该线程为守护线程
t.setDaemon(true);
t.start();

常见的守护线程：

• 垃圾回收器线程就是一种守护线程
• Tomcat 中的Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

四、线程状态

进程的状态参考操作系统：创建态、就绪态、运行态、阻塞态、终止态

六种状态

线程由生到死的完整过程（生命周期）：当线程被创建并启动以后，既不是一启动就进入了执行状态，也不是一直处于执行状态，在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
NEW（新建）	线程刚被创建，但是并未启动，还没调用 start 方法，只有线程对象，没有线程特征
Runnable（可运行）	当调用了 start() 方法之后，Java API 层面的RUNNABLE 状态涵盖了操作系统层面的 【就绪态】、【运行态】和【阻塞态】
Blocked（锁阻塞）	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入 Blocked 状态；当该线程持有锁时，该线程将变成 Runnable 状态
Waiting（无限等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入 Waiting 状态，进入这个状态后不能自动唤醒，必须等待另一个线程调用 notify 或者 notifyAll 方法才能唤醒
Timed Waiting （计时等待）	有几个方法有超时参数，调用将进入 Timed Waiting 状态，这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有 Thread.sleep 、Object.wait
Terminated（被终止）	run 方法正常退出而死亡，或者因为没有捕获的异常终止了 run 方法而死亡

---

参考：

• Java并发编程 一 线程介绍、创建线程的4种方式、线程常用方法、两阶段终止状态、线程的五种/六种状态
• JavaNotes — JUC