多线程与并发

1 进程和线程的区别

1.1 进程和线程的由来

1.2 区别

总结

2 start（） 和 run（）区别

创建一个测试用例
run（）：

start（）：

通过上面两种情况，我们能够知道，run方法不会创建一个新线程。start方法会创建一个新线程。可以看看openjdk的源码

3 Thread 和 Runnable区别

查看源码发现，Runnable只有run方法，所以只通过它是无法实现多线程的（需要依赖Thread中的start方法才能实现多线程）。

区别：
Thread是实现了Runnable接口的类，能够支持多线程
由于java单一继承的原则（线程类继承了Thread就无法继承别的了），一般使用Runnable接口。

3 run方法传参和处理线程返回值

3.1传参

三种传参方法

3.2 处理线程返回值

1.主线程等待法
等待子线程返回值后才停止sleep。缺点主线程等待的时间不好计算（如下面等待100毫秒）

使用join（）阻塞主线程
子线程使用join方法阻塞主线程的执行。
缺点：在多个线程的时候无法做到精确控制。

通过Callable接口实现，使用FutroeTask 或者 线程池
FutureTask方法

使用线程池，MyCallable类和上面一样（优点：可以让线程池并发执行结果）。注意要关闭线程池。

4 sleep 和 wait 的区别

5 notify 和 notifyall区别

5.1 锁池、等待池

• 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。

• 等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。

5.2 区别

notifyall：会让该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。
notify：仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.

5.3 yield

一个调用yield()方法的线程告诉虚拟机它乐意让其他线程占用自己的位置。这表明该线程没有在做一些紧急的事情。注意，这仅是一个暗示，并不能保证不会产生任何影响。（并且不会对锁行为造成任何影响）

6 中断线程

线程停止有四种种情况：
1.run运行结束
2.异常退出
3.stop强制中止，这个不推荐使用，存在风险，比如说扫尾清理工作未完成，关闭资源未完成 就退出了。
4.interrupt方法中断线程， 需要主动编码配合，写中断逻辑，但是可控。


例如：

public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Runnable interruptTask = new Runnable() {
            @Override
            public void run() {
                int i = 0;
                try {
                    //在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程
                    while (!Thread.currentThread().isInterrupted()) {
                        Thread.sleep(100); // 休眠100ms
                        i++;
                        System.out.println(Thread.currentThread().getName() + " (" + Thread.currentThread().getState() + ") loop " + i);
                    }
                } catch (InterruptedException e) {
                    //在调用阻塞方法时正确处理InterruptedException异常。（例如，catch异常后就结束线程。）
                    System.out.println(Thread.currentThread().getName() + " (" + Thread.currentThread().getState() + ") catch InterruptedException.");
                }
            }
        };
        Thread t1 = new Thread(interruptTask, "t1");
        System.out.println(t1.getName() +" ("+t1.getState()+") is new.");

        t1.start();                      // 启动“线程t1”
        System.out.println(t1.getName() +" ("+t1.getState()+") is started.");

        // 主线程休眠300ms，然后主线程给t1发“中断”指令。
        Thread.sleep(300);
        t1.interrupt();
        System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");

        // 主线程休眠300ms，然后查看t1的状态。
        Thread.sleep(300);
        System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
    }
}

执行结果

7 线程状态及它们的切换

8 synchronized

线程安全诱因
存在可变的共享数据，并且同时有多条线程共同操作这些资源
解决问题的根本方法：在同一时刻有且只有一个线程在操作共享数据，其它线程必须等待该线程处理完zhihou再对恭共享数据进行操作

互斥锁的特性

8.1 用法

synchronized锁的不是代码而是对象。
根据获取锁的分类可分为：获取对象锁和获取类锁

获取对象锁的2种方法

• 一般一个对象锁是对一个非静态成员变量进行synchronized修饰，例如synchronized（this）
• 对一个非静态成员方法进行synchronized进行修饰

以上两种锁的都是对象，若对象是同一个那么他们是互斥的。
例如：

1 void myMethod(){
 2     synchronized(this){
 3         //code
 4     }
 5 }
 6 
 7 /*is equvilant to*/
 8 void synchronized myMethod(){
 9     //code
10 }

获取类锁的2种方法

• 同步代码块（synchronized（类.class））
• 同步静态方法（synchronized static method）锁的是当前对象的类对象

总结

8.2 synchronized 的底层实现原理

实现synchronized的基础

• java对象头
• monitor
  对象头
  
  Mark Word中具有指向锁的引用比如指向重量锁monior的
  
  

8.3 自旋锁

8.4 锁消除和锁粗化

锁消除
JIT编译时，对向上下文进行扫描，去除不可能存在竞争的锁
锁粗化

synchronized的四种状态

synchronized 和 ReentrantLock（再入锁）区别

9 线程池

9.1 五种线程池

使用Executor创建

ForkJoinPoll

9.2 为什么要使用线程池

降低资源消耗、提高线程的可管理性。