public void run() {System.out.println("This is child thread");}}public static void main(String[] args) {MyThread thread = new MyThread();thread.start();}}

• 实现 Runnable 接口 run()方法

public class RunnableTask implements Runnable {public void run() {System.out.println("Runnable!");}public static void main(String[] args) {RunnableTask task = new RunnableTask();new Thread(task).start();}}

上面两种都没有返回值。

• 实现 Callable 接口 call()方法，这种方式可以通过 FutureTask 获取任务执行的返回值

public class CallerTask implements Callable<String> {public String call() throws Exception {return "Hello,i am running!";}public static void main(String[] args) {//创建异步任务 FutureTask<String> task=new FutureTask<String>(new CallerTask());//启动线程 new Thread(task).start();try {//等待执行完成，并获取返回结果 String result=task.get();System.out.println(result);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}}

3、常用方法

3.1、线程等待与通知

在 Object 类中有一些函数可以用于线程的等待与通知。

• wait()：当一个线程调用一个共享变量的?wait()方法时， 该调用线程会被阻塞挂起， 到发生下面几件事情之一才返回 ：（1） 线程调用了该共享对象?notify()或者?notifyAll()方法；（2）其他线程调用了该线程?interrupt() 方法，该线程抛出 InterruptedException 异常返回。

• wait(long timeout)?：该方法相?wait() 方法多了一个超时参数，它的不同之处在于，如果一个线程调用共享对象的该方法挂起后，没有在指定的?timeout ms时间内被其它线程调用该共享变量的notify()或者?notifyAll() 方法唤醒，那么该函数还是会因为超时而返回。

• wait(long timeout, int nanos)，其内部调用的是?wait(long timout）函数。

上面是线程等待的方法，而唤醒线程主要是下面两个方法：

• notify()?: 一个线程调用共享对象的 notify() 方法后，会唤醒一个在该共享变量上调用 wait 系列方法后被挂起的线程。 一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。

• notifyAll()?：不同于在共享变量上调用 notify() 函数会唤醒被阻塞到该共享变量上的一个线程，notifyAll()方法则会唤醒所有在该共享变量上由于调用 wait 系列方法而被挂起的线程。

如果有这样的场景，需要等待某几件事情完成后才能继续往下执行，比如多个线程加载资源，需要等待多个线程全部加载完毕再汇总处理。Thread 类中有一个 join 方法可实现。

3.2、线程休眠

Thread 类中有一个静态态的 sleep 方法，当一个个执行中的线程调用了 Thread 的 sleep 方法后，调用线程会暂时让出指定时间的执行权，也就是在这期间不参与 CPU 的调度，但是该线程所拥有的监视器资源，比如锁还是持有不让出的。指定的睡眠时间到了后该函数会正常返回，线程就处于就绪状态，然后参与 CPU 的调度，获取到 CPU 资源后就可以继续运行。

3.3、让出优先权

Thread 有一个静态 yield 方法，当一个线程调用 yield 方法时，实际就是在暗示线程调度器当前线程请求让出自己的 CPU 使用，但是线程调度器可以无条件忽略这个暗示。

当一个线程调用 yield 方法时， 当前线程会让出 CPU 使用权，然后处于就绪状态，线程调度器会从线程就绪队列里面获取一个线程优先级最高的线程，当然也有可能会调度到刚刚让出 CPU 的那个线程来获取 CPU 行权。

3.4、线程中断

Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。

• void interrupt()?：中断线程，例如，当线程 A 运行时，线程 B 可以调用线程 interrupt() 方法来设置线程的中断标志为 true 并立即返回。设置标志仅仅是设置标志, 线程 A 实际并没有被中断， 会继续往下执行。如果线程 A 因为调用了 wait() 系列函数、 join 方法或者 sleep 方法阻塞挂起，这时候若线程 B 调用线程 A 的 interrupt()方法，线程 A 会在调用这些方法的地方抛出 InterruptedException 异常而返回。

• boolean isInterrupted() 方法： 检测当前线程是否被中断。

• boolean interrupted() 方法： 检测当前线程是否被中断，与 isInterrupted 不同的是，该方法如果发现当前线程被中断，则会清除中断标志。

4、线程状态

上面整理了线程的创建方式和一些常用方法，可以用线程的生命周期把这些方法串联起来。

在 Java 中，线程共有六种状态：

线程在自身的生命周期中， 并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换，Java 线程状态变化如图示：

5、线程上下文切换

使用多线程的目的是为了充分利用 CPU，但要认识到，每个 CPU 同一时刻只能被一个线程使用。

为了让用户感觉多个线程是在同时执行的， CPU 资源的分配采用了时间片轮转也就是给每个线程分配一个时间片，线程在时间片内占用 CPU 执行任务。当线程使用完时间片后，就会处于就绪状态并让出 CPU 让其他线程占用，这就是上下文切换。

6、线程死锁

死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的互相等待的现象，在无外力作用的情况下，这些线程会一直相互等待而无法继续运行下去。

那么为什么会产生死锁呢？ 死锁的产生必须具备以下四个条件：

• 互斥条件：指线程对己经获取到的资源进行它性使用，即该资源同时只由一个线程占用。如果此时还有其它线程请求获取获取该资源，则请求者只能等待，直至占有资源的线程释放该资源。

• 请求并持有条件：指一个 线程己经持有了至少一个资源，但又提出了新的资源请求，而新资源己被其它线程占有，所以当前线程会被阻塞，但阻塞 的同时并不释放自己已经获取的资源。

• 不可剥夺条件：指线程获取到的资源在自己使用完之前不能被其它线程抢占，只有在自己使用完毕后才由自己释放该资源。

• 环路等待条件：指在发生死锁时，必然存在一个线程——资源的环形链，即线程集合 {T0，T1，T2,…… ，Tn} 中 T0 正在等待一 T1 占用的资源，Tl1 正在等待 T2 用的资源，…… Tn 在等待己被 T0 占用的资源。

该如何避免死锁呢？答案是至少破坏死锁发生的一个条件。

其中，互斥这个条件我们没有办法破坏，因为用锁为的就是互斥。不过其他三个条件都是有办法破坏掉的，到底如何做呢？

• 对于“请求并持有”这个条件，可以一次性请求所有的资源。

• 对于“不可剥夺”这个条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源，这样不可抢占这个条件就破坏掉了。

• 对于“环路等待”这个条件，可以靠按序申请资源来预防。所谓按序申请，是指资源是有线性顺序的，申请的时候可以先申请资源序号小的，再申请资源序号大的，这样线性化后就不存在环路了。

7、线程分类

Java 中的线程分为两类，分别为?**daemon 线程（守护线程）**和?user 线程（用户线程）。

在 JVM 启动时会调用 main 函数，main 函数所在的线程就是一个用户线程。其实在 JVM 内部同时还启动了很多守护线程， 比如垃圾回收线程。

那么守护线程和用户线程有什么区别呢？区别之一是当最后一个非守护线程束时， JVM 会正常退出，而不管当前是否存在守护线程，也就是说守护线程是否结束并不影响 JVM 退出。换而言之，只要有一个用户线程还没结束，正常情况下 JVM 就不会退出。

8、ThreadLocal

ThreadLocal 是 JDK 包提供的，它提供了线程本地变量，也就是如果你创建了 ThreadLocal ，那么访问这个变量的每个线程都会有这个变量的一个本地副本，当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建 ThreadLocal 变量后，每个线程都会复制 到自己的本地内存。

可以通过 set(T)方法来设置一个值，在当前线程下再通过 get()方法获取到原先设置的值。

下面来看一个 ThreadLocal 的使用实例：

public class ThreadLocalTest {//创建 ThreadLocal 变量 static ThreadLocal<String> localVar = new ThreadLocal<String>();//打印函数 static void print(String str) {//打印当前线程本地内存中 localVar 变量值 System.out.println(str + ":" + localVar.get());//清除前线程本地内存中 localVar 变量值//localVar.remove();}public static void main(String[] args) {Thread thread1 = new Thread(new Runnable() {public void run() {//设置线程 1 中本地变量 localVal 的值 localVar.set("线程 1 的值");//调用打印函数 print("线程 1");//打印本地变量的值 System.out.println("线程 1 打印本地变量后：" + localVar.get());}});Thread thread2 = new Thread(new Runnable() {public void run() {//设置线程 2 中本地变量 localVal 的值 localVar.set("线程 2 的值");//调用打印函数 print("线程 2");//打印本地变量的值 System.out.println("线程 2 打印本地变量后：" + localVar.get());}});thread1.start();thread2.start();}}

【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开：qq.cn.hn/FTf 免费领取

9、Java 内存模型

在 Java 中，所有实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享 。

Java 线程之间的通信由 Java 内存模型控制，Java 内存模型决定一个线程对共享变量的写入何时对另一个线程可见。

从抽象的角度来看，Java 内存模型定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是 Java 内存模型的 一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。