实现多线程的方法
根据Oracle官方文档，实现多线程的方法只有两种 一、实现Runnable接口，重写run，运行start() 二、继承Thread类，重写run，运行start()
准确地讲，实现多线程只有一种方式，构建一个Thread类。而实现线程执行单元有种方式，实现Runnable接口和继承Thread类。
两种方式的本质：
实现Runnable接口：底层调用了target.run() 继承Thread类：重写了整个run方法
Runnable和Thread的区别
Java不允许多继承，实现runnable接口可以再继承其他类，而Thread不行 Runnable可以实现多个相同的程序代码的线程去共享一个资源，Thread也可以，但从Thread的源码可以看到，当Thread方式去实现资源共享时，实际上源码内部是将thread向下转型为了runnable，其内部依然是一runnable形式去实现资源的共享的。
线程池，collable创建线程的本质，也是新建了一个thread类
启动线程的正确方式
使用start()方法
start()和run()区别
start（）：
由主线程创建子线程，告诉JVM，让JVM在合适的时候启动。 方法含义： 启动新线程、顺序由JVM来分配调度 分配资源 运行线程 通过源码可知，启动新线程时， 1.先检查线程的状态，如果不为0，才运行，否则报IllegalThreadStateException 2.加入线程组 3.调用native本地方法 start0
run()：
通过阅读源码，run方法并没有真正的启动线程，而是由一个main的主线程去调用run方法，这个方法和普通的方法没有区别，run方法的执行线程是主线程，并没有创建新线程。 runnable其实相对于一个task，并不具有线程的概念，如果你直接去调用runnable的run，其实就是相当于直接在主线程中执行了一个函数而已，并未开启线程去执行
如何正确停止线程
通过interrupt来通知线程停止，而不是强制停止
具体场景
通常情况下，代码执行完，线程就会停止运行。 正确方法： 使用interrupt来请求停止线程 [好处是能保证数据安全，把主动权交给被中断的线程]。
要正确停止线程，还需要请求方、被请求方、子方法被调用方互相配合。具体如何配合？
Q:为什么volatile设置boolean是错的？ A:因为它无法长时间处理线程阻塞的情况
Q:如何处理不可中断的阻塞？ A:没有通用的解决方案，具体情况具体分析，编写代码过程中尽量选择可以中断的方法。
可以为了响应中断而抛出InterruptedException的常见方法列表
Object. wait()/ wait( long)/ wait( long, int)Thread. sleep( long) /sleep( long, int)Thread. join()/ join( long)/ join( long, int)java. util. concurrent. BlockingQueue. take() /put( E)java. util. concurrent. locks. Lock. lockInterruptibly()java. util. concurrent. CountDownLatch. await()java. util. concurrent. CyclicBarrier. await()java. util. concurrent. Exchanger. exchange(V)java.nio.channels.InterruptibleChannel相关方法java.nio.channels.Selector的相关方法
线程的生命周期
线程的六种状态
New 新建 [start尚未执行] Runnable 运行 [就绪和运行状态(ready)和(running)] Blocked 阻塞 [被Synchronized所修饰的代码块/方法] Waiting 等待 [不带参，有锁会释放] TimedWaiting 超时等待 [计时等待 带time参数] Terminated 终止
一般习惯而言，把Blocked(被阻塞）、Waiting(等待）、Timed_waiting(计时等待）都称为阻塞状态。
lock不会主动释放锁，要手动释放
线程sleep的时候不会释放Synchronized的monitor，sleep时间到了，正常结束或抛异常，才会释放锁
wait/notify/notifyAll的特点、性质
用必须先拥有monitor 只能唤醒其中一个 属于Object类 类似功能的Condition 同时持有多个锁的情况
生产者消费者模式
Q:为什么要使用这种模式？ A:使生产者和消费者解耦，生产者只需把生产好的数据往缓冲区放，消费者只管从缓冲区取。两者更好的配合[平衡生产快，消费慢的矛盾]
手写生产者消费者模式
package threadcoreknowledge
.threadobjectclasscommonmethods
;
import java
.util
.Date
;
import java
.util
.LinkedList
;
public class ProducerConsumerModel {
public static void main(String
[] args
) {
EventStorage eventStorage
= new EventStorage();
Producer producer
= new Producer(eventStorage
);
Consumer consumer
= new Consumer(eventStorage
);
new Thread(producer
).start();
new Thread(consumer
).start();
}
}
class Producer implements Runnable {
private EventStorage storage
;
public Producer(
EventStorage storage
) {
this.storage
= storage
;
}
@Override
public void run() {
for (int i
= 0; i
< 100; i
++) {
storage
.put();
}
}
}
class Consumer implements Runnable {
private EventStorage storage
;
public Consumer(
EventStorage storage
) {
this.storage
= storage
;
}
@Override
public void run() {
for (int i
= 0; i
< 100; i
++) {
storage
.take();
}
}
}
class EventStorage {
private int maxSize
;
private LinkedList
<Date> storage
;
public EventStorage() {
maxSize
= 10;
storage
= new LinkedList<>();
}
public synchronized void put() {
while (storage
.size() == maxSize
) {
try {
wait();
} catch (InterruptedException e
) {
e
.printStackTrace();
}
}
storage
.add(new Date());
System
.out
.println("仓库里有了" + storage
.size() + "个产品。");
notify();
}
public synchronized void take() {
while (storage
.size() == 0) {
try {
wait();
} catch (InterruptedException e
) {
e
.printStackTrace();
}
}
System
.out
.println("拿到了" + storage
.poll() + "，现在仓库还剩下" + storage
.size());
notify();
}
}
线程的各属性
优先级、各属性[ID,Name,IsDaemon,Priority]
守护线程特性[1.线程继承于父线程 2.被谁启动 3.不影响JVM的退出]
Q:守护线程和普通线程的区别？ A: ◆ 整体上没有区别 ◆ 唯一区别在于是否影响JVM退出
守护线程主要用于给用户线程提供服务
线程优先级 默认为5，,10个级别
◆ 程序设计不应该依赖于优先级 ◇ 不同操作系统的优先级映射和调度都不同 ◇ 优先级会被操作系统改变
线程的未捕获异常怎么处理？
Q：为什么会捕获不到异常？
A：对于主线程来说，可以轻松发现异常，但子线程不行，如果子线程发生异常，无法用传统的方法捕获
解决方案 ◆ 在每个run方法加try catch[不推荐] ◆ 利用UncaughtExceptionHandler全局捕获异常[推荐]
UncaughtExceptionHandler
package threadcoreknowledge
.uncaughtexception
;
import java
.util
.logging
.Level
;
import java
.util
.logging
.Logger
;
public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
private String name
;
public MyUncaughtExceptionHandler(String name
) {
this.name
= name
;
}
@Override
public void uncaughtException(Thread t
, Throwable e
) {
Logger logger
= Logger
.getAnonymousLogger();
logger
.log(Level
.WARNING
,"线程异常，终止了"+t
.getName(),e
);
System
.out
.println(name
+"捕获了异常"+t
.getName()+"异常"+e
);
}
}
UseUncaughtExceptionHandler
package threadcoreknowledge
.uncaughtexception
;
public class UseOwnUncaughtExceptionHandler implements Runnable{
public static void main(String
[] args
) throws InterruptedException
{
try{
Thread
.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler("捕获器1 "));
new Thread(new UseOwnUncaughtExceptionHandler(),"My Thread -1").start();
Thread
.sleep(300);
new Thread(new UseOwnUncaughtExceptionHandler(),"My Thread -2").start();
Thread
.sleep(300);
new Thread(new UseOwnUncaughtExceptionHandler(),"My Thread -3").start();
Thread
.sleep(300);
new Thread(new UseOwnUncaughtExceptionHandler(),"My Thread -4").start();
Thread
.sleep(300);
}catch (RuntimeException e
){
System
.out
.println("Caught Exception.");
}
}
@Override
public void run() {
throw new RuntimeException();
}
}
线程性能和安全问题
Q：◆ 什么是线程安全？
不管业务中遇到怎样的多个线程访问某对象或者某方法的情况，在编写这个业务逻辑的时候，都不需要额外的做任何处理，线程也可以正常运行(得到正确的结果)，就可以成为线程安全。
<当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全的>
Q：◆ 什么情况下会出现线程安全问题
◇ 运行结果错误（i++） ◇ 活跃性问题：死锁、活锁、饥饿 ◇ 对象发布和初始化的安全问题
Q：◆ 什么是对象发布
指的是“使对象能够在当前作用域之外的代码使用”。主要集中在public方法
◇ return 一个private对象
Q：◆什么是对象溢出
“对象逸出”指的是某不应该发布的对象被发布的情况，对象发布、创建最容易犯的错误就是对象逸出。
◇ 方法返回一个private对象 ◇ 还未完成初始化（构造函数还没完全执行完毕），就把对象提供给外界 ◇ ↑{ 1.构造函数中未初始化完毕就this赋值 2.注册监听事件 3.构造函数中运行线程 }
如何解决？
◇ 返回副本，而不是对象的引用 ◇ 用工厂模式生产对象
各种需要考虑线程安全的情况
◆ 访问共享的静态变量或资源，会有并发风险 [如对象的属性、静态变量、共享缓存、数据库]
◆ 所有依赖时序的操作，即使线程是安全的 [read-modify-write,check-then-act]
◆ 不同数据存在捆绑关系 [ip和端口]
◆ 使用其他类时，对方没有声明自己线程是安全时 [hashmap]
线程带来的性能问题
◆ 性能问题的体现 ◇ 服务响应慢、吞吐量低、资源消耗（例如内存）过高等 ◇ 虽然不是结果错误，但依然危害巨大(据统计)
为什么多线程会带来性能问题
◆ 调度：
频繁的上下文切换
Q：◇ 什么是上下文切换？
上下文切换可以认为是内核（操作系统的核心）在 CPU 上对于进程（包括线程）进行以下的活动： （1）挂起一个进程，将这个进程在 CPU 中的状态（上下文）存储于内存中的某处， （2）在内存中检索下一个进程的上下文并将其在 CPU 的寄存器中恢复，（3）跳转到程序计数器所指向的位置（即跳转到进程被中断时的代码行），以恢复该进程。
Q：◇ 何时导致密集的上下文切换？
频繁的竞争锁、IO的读写操作等
同时还会带来额外的缓存开销
◆ 协调：内存同步 涉及到Java内存模型
Thread和Object类中和和线程相关的重要方法
Q：为什么wait()需要在同步代码块内使用，而sleep()不需要？
[防止wait之后没有notify来唤醒，防止线程安全问题的发生]
这是Java设计者为了避免使用者出现lost wake up问题而搞规定的
Lost Wake Up问题 假设有两个线程，一个消费者一个生产者 生产者任务简化成将Count+1，而后唤醒消费者 消费者任务简化成将Count-1，在减到0的时候陷入睡眠
初始化的时候，count为0，这是消费者判断到Count小于等于0，正准备睡眠 而在这瞬间，生产者已把步骤执行完了，发出了通知（notify），这时候消费者还醒着，正准备睡眠，notify毫无效果，通知就丢掉了。紧接着，消费者进入休眠状态。
那么怎么解决这个问题呢？
现在我们应该就能够看到，问题的根源在于，消费者在检查count到调用wait()之间，count就可能被改掉了。 这就是一种很常见的竞态条件。 很自然的想法是，让消费者和生产者竞争一把锁，竞争到了的，才能够修改count的值。 于是生产者的代码是:
trylock()
count
+1
notify()
releaseLock()
消费者
tryLock（）
while(count
<=0){
wait();
}
count
-1;
releaseLock();
Q：3.为什么wait()需要在同步代码块内使用，而sleep()不需要
wait()需要在同步代码块内使用主要让通信变得可靠，防止线程死锁，如果不把wait/notify放在同步代码块中的话，很有可能在执行wait之前，线程很有可能已经切换到了另一个执行notify的线程，这样的话有可能另一个线程先把notify都执行完毕了，那wait永远没有被唤醒了，这就导致了永久等待或者死锁的发生，这就需要把两个方法都放到同步代码块中去。 sleep()只关心自己这个线程，和其他线程关系并不大，所以并不需要同步。
Q：4.为什么线程通信的方法wait()，notify()和notifyAll()被定义在Object类里？而sleep定义在Thread类里？
因为在java中，wait()，notify()和notifyAll()属于锁级别的操作，而锁是属于某个对象的。
Q：wait方法是属于Object对象的，那调用Thread.wait会怎么样？
Thread也是个对象，这样调用也没有问题，但是Thread是个特殊的对象，线程退出的时候会自动执行notify，这样会是我们设计的流程受到干扰，所以我们一般不这么用。
Q：6.如何选择用notify还是notifyAll？
唤醒多个线程和一个线程的区别。
Q：7.notifyAll之后所有的线程都会再次抢夺锁，如果某线程抢夺失败怎么办？
没抢到锁的线程处于等待状态，等待锁的释放
Q：8.用suspend和resume来阻塞线程可以吗？为什么
这两个方法被弃用了，推荐使用wait、notify。
Q：9.讲讲sleep方法的特点？
相同点
wait和sleep方法都可以使线程阻塞，对应线程状态是Waiting或Time_Waiting。 wait和sleep方法都可以响应中断Thread.interrupt()。 不同点
wait方法的执行必须在同步方法中进行，而sleep则不需要 在同步方法里执行sleep方法时，不会释放monitor锁，但是wait方法会释放monitor锁。 sleep方法短暂休眠之后会主动退出阻塞，而没有指定时间的wait方法则需要被其他线程中断后才能退出阻塞。 wait()、notify()和notifyAll()是Object类的方法， sleep()和yeild()是Thread类的方法。
