Java面试之高并发_java高并发面试

go实现12306抢票系统
秒杀系统的设计
kafka

1.sleep(0)和wait()方法

sleep()&wait()
sleep(0)详细解读，建议深度理解下
（1）从使用者角度，sleep是Thread中的方法，wait()是Object()方法；
（2）从使用地方角度，sleep可以任意使用，而wait只能在sychronized代码块中使用。
（3）从释放锁的角度来说，sleep不会释放锁，他也不需要占用锁。而wait会释放锁（但是调用它的前提是当前线程占有锁）；
（4）从唤醒角度来说，sleep在时间到了之后会自动进去可运行态。而wait()必须通过notify方法唤醒。
（5）他们都可以被interrupted（）方法打断
（6）Thread.sleep(0)

Thread.Sleep(1000) 意思是在未来的1000毫秒内本线程不参与CPU竞争，1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。另外值得一提的是Thread.Sleep(0)的作用，就是触发操作系统立刻重新进行一次CPU竞争，竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。

wait(1000)表示将锁释放1000毫秒，到时间后如果锁没有被其他线程占用，则再次得到锁，然后wait方法结束，执行后面的代码，如果锁被其他线程占用，则等待其他线程释放锁。注意，设置了超时时间的wait方法一旦过了超时时间，并不需要其他线程执行notify也能自动解除阻塞，但是如果没设置超时时间的wait方法必须等待其他线程执行notify。

2.读写锁

读写锁

一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容。读写锁比互斥锁允许对于共享数据更大程度的并发。每次只能有一个写线程，但是同时可以有多个线程并发地读数据。

• 如果当前没有写锁或读锁时，第一个获取锁的线程都会成功，无论该锁是写锁还是读锁。
• 如果当前已经有了读锁，那么这时获取写锁将失败，获取读锁有可能成功也有可能失败
• 如果当前已经有了写锁，那么这时获取读锁或写锁，如果线程相同（可重入），那么成功；否则失败

3.多线程的实现方式？

（1）继承thread类，重写run()方法，太局限。
（2）实现runable()接口
（3）实现Callnable接口，重写call方法，带有返回值
（4）线程池的方式

4.java锁的种类？公平锁/非公平锁；可重入锁；互斥锁/读写锁；乐观锁/悲观锁；

读写锁

5.线程的同步方式？

6.volatile和synchronized关键字的原理

为什么synchronized安全？
使用 javap -v 查看字节码文件发现，monitorenter 和 monitorexit 两个独有的指令。执行同步代码后首先要先执行 monitorenter 指令，退出的时候monitorexit 指令。使用Synchronized 进行同步，其关键就是必须要对对象的监视器 monitor 进行获取，当线程获取 monitor 后才能继续往下执行，否则就只能等待。而这个获取的过程是互斥的，即同一时刻只有一个线程能够获取到monitor。

volatile禁止指令重排：

• 在jvm层级，被volatile关键字修饰的变量，对其读写需要添加内存屏障，内存屏障的意思就是在本条指令前后添加内存屏障，不让其和前面和后面的指令重排序。那么是怎么实现的呢？通过查看源码，可以发现其底层采用 lock 这条指令实现。 lock指令的意思就是强制刷新cpu的缓存。确保获取的是最新数据。就是将我们之前指令修改的数据都刷新到缓存中，确保其立即生效。而lock之后，也就是我们volatile修饰的变量就不会参与指令的重排序。

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”
lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
2）它会强制将对缓存的修改操作立即写入主存；
3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

7.ConcourrentHashMap怎么保证线程安全

8.怎么保证线程安全？

• 首先应该避免全局变量，采用局部变量。如果非要使用的话，可以采用final类型，或者使用ThreadLocal;
• 对于单个变量共享的话，可以采用volatile关键字来确保线程安全；
• 委托线程安全的类去保证线程安全(并发容器(vector)、同步容器concurrentHashMap)
• 如果代码块需要同步的话，可以采用lock和synchronized。

9.Java结束线程的三种的方式？

参考

• 线程run()方法执行结束，正常退出；
• 使用interrupt()方法中断线程。当线程调用sleep()方法之后，通过try-catch来捕获异常，然后结束线程。假如线程run()方法是个while循环。
• 使用stop()方法，不建议，立即释放锁，停止线程，使得某些操作可能得不到执行，引发数据不安全问题。
• 设置一个标志，用来退出，一般是volatile修饰的。

10.CAS原理

CAS并发原语提现在Java语言中就是sun.miscUnSafe类中的各个方法。调用UnSafe类中的CAS方法,JVM会帮我实现CAS汇编指令.这是一种完全依赖于硬件 功能,通过它实现了原子操作。再次强调,由于CAS是一种系统原语,原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许中断,也即是说CAS是一条原子指令,不会造成所谓的数据不一致的问题。

11.原子类Atomiclnteger的ABA问题谈谈?原子更新引用知道吗？

12.CountDownLatch/CyclicBarrier/Semaphore使用过吗？

13.阻塞队列知道吗？

阻塞队列

14.线程池用过吗？ThreadPoolExecutor谈谈你的理解？

线程池
AbortPolicy：直接抛出异常，阻止系统正常运行。
CallerRunsPolicy ：只要线程池未关闭，该策略直接在调用者线程中，运行当
前被丢弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极
有可能会急剧下降。
DiscardOldestPolicy ：丢弃最老的一个请求，也就是即将被执行的任务，并
尝试再次提交当前任务。
DiscardPolicy ：该策略默默地丢弃无法处理的任务，不予任何处理。如果允
许任务丢失，这是最好的一种方案。

常用线程池：

1. Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行，适用于一个一个任务执行的场景
2. Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过 60 秒内没执行，那么将被终止并从池中删除，适用执行很多短期异步的小程序或者负载较轻的服务
3. Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务，性能好很多。
4. Executors.newScheduledThreadPool()：用来调度即将执行的任务的线程池
5. newWorkStealingPool(int parallelism)，这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建 ForkJoinPool，利用Work-Stealing 算法，并行地处理任务，不保证处理顺序。

FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列⻓度为
Integer.MAX_VALUE，可能堆积⼤量的请求，从⽽导致 OOM。
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为
Integer.MAX_VALUE，可能会创建⼤量线程，从⽽导致 OOM。

线程池大小的设定：

1. CPU密集型（该任务需要大量的运算，而没有阻塞，cpu一直全速运行）（CPU核数+1）
2. IO密集型（CPU*2）(cpu核数/（1-阻塞系数）系数在0.8-0.9之间)

15.lock中独占锁和共享锁的实现：

16.谈谈LockSupport

17.线程的状态

1. new （new出了线程对象，但还没有调用start()方法）
2. running（就绪和运行）
3. blocked（阻塞状态，其中有一个 monitor lock 字眼，了解sychronized关键字的应该比较熟悉。不就是对象监视器吗。重量级锁实现的依赖。那么回到这里，说明这个状态是在等待其他线程释放锁。）
4. waitting（需要其他线程唤醒）
5. time_waitting（有时间参数，到了时间自动唤醒）
6. TERMINATED（这个状态比较好理解，其实就是我们的线程执行结束了。也就是run()方法中的代码执行完成）

线程状态之间的转换

18.sleep（） 、wait()、yield()、join() 、park()的区别

1. sleep方法在Thread中的方法，调用的过程中不会释放锁，进行阻塞，睡眠时间到后自动释放执行。
2. wait()方法，Object中的方法，调用的时候会阻塞当前线程，并且会释放锁。自己不能从等待状态中出来，需要其他线程调用notify()方法。并且只能在同步代码块中使用，因为是需要释放锁的。
3. yield方法，也是Thread中的方法，同样不会释放锁，会让出当前cpu的执行权，和sleep方法不同的是，他不会进行阻塞，只是将当前线程调整为可运行态，那么就可能存在刚调用这个方法后，该线程又立马执行。
4. join（）方法，用来确保线程的执行顺序，调用join方法会优先执行，是Thread中的一个实例方法，但底层采用wait方法实现，所以会释放锁。thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
5. park（）方法是unsafe类中的方法，用来使用在并发包中，比wait更灵活，可以通过unpark方法唤醒指定线程。感觉sleep()方法更强调的是放弃cpu竞争权力多少秒。而wait()方法强调的是线程间的通信。

19.Stop 和 suspend方法

stop以及suspend

20. 锁和同步的区别：用法、实现、性能

添加链接描述

21.JMM: 讨论的是并发的问题，主内存、工作内存。从原子性、有序性、可见性分析。

22.java中用到的定时任务：

（1）Timer类，缺点，单个线程执行任务，当前一个任务出现问题时，会影响后续的任务 . （2）SpringBoot定时器：

23. NIO中三种reactor模式：

（1）单线程，处理单个事件如果过慢，就会造成其他事件拥堵情况。
（2）线程池，单个线程只处理分发任务，具体执行流程交给线程池执行。这时候单个线程的分发可能会成为瓶颈，比如说我们有一万个连接，同时还有一万个正在写的事件。那么单线程的分发负载就会过大。
（3）主从模式，主select()负责处理连接，而从select()负责读写事件。支持高程度的并发。

24.锁消除和锁粗化

锁消除和锁粗话

25.公平锁和非公平锁区别？为什么公平锁效率低？

公平锁：
公平锁自然是遵循 FIFO（先进先出）原则的，先到的线程会优先获取资源，后
到的会进行排队等待
优点：所有的线程都能得到资源，不会饿死在队列中。
缺点：吞吐量会下降，队列里面除了第一个线程，其他的线程都会阻塞，cpu
唤醒阻塞线程的开销大
非公平锁：
多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，
如果能获取到，就直接获取到锁。
优点：可以减少 CPU 唤醒线程的开销，整体的吞吐效率会高点，CPU 也不必取
唤醒所有线程，会减少唤起线程的数量。
缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者
长时间获取不到锁
公平锁效率低原因：
公平锁要维护一个队列，后来的线程要加锁，即使锁空闲，也要先检查有没有
其他线程在 wait，如果有自己要挂起，加到队列后面，然后唤醒队列最前面线
程。这种情况下相比较非公平锁多了一次挂起和唤醒。
线程切换的开销，其实就是非公平锁效率高于公平锁的原因，因为非公平锁减
少了线程挂起的几率，后来的线程有一定几率逃离被挂起的开销。

26.JMM

Java 内存模型（Java Memory Model，JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了 Java 程序在各种平台下对内存的访问都能保证效果一致的机制及规范。

JMM 是一种规范，是解决由于多线程通过共享内存进行通信时，存在的本地内
存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的
问题。目的是保证并发编程场景中的原子性、可见性和有序性。

所以，Java 内存模型，除了定义了一套规范，还提供了一系列原语，封装了底
层实现后，供开发者直接使用。我们前面提到，并发编程要解决原子性、有序性
和一致性的问题。

27.手写简单的线程池，提现线程的复用

手写线程池

28.手写生产者 消费者

package pro_cum;

public class sync {
    public static void main(String[] args) {
        Data data=new Data();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.increase();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.decrease();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.increase();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.decrease();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();


    }
}
class Data{
    private int num=0;
    public synchronized void increase() throws InterruptedException {
        while(num!=0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "值为:" + num);
        this.notifyAll();
    }
    public synchronized void decrease() throws InterruptedException {
        while(num==0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "值为:" + num);
        this.notifyAll();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

29.手写阻塞队列

手写阻塞队列

30.手写多线程循环打印ABC

package leetcode;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ABC {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Runnable runa=new Runnable() {
            @Override
            public void run() {
                System.out.println("A");
                //executorService.execute(this::run);
            }
        };
        Runnable runb=new Runnable() {
            @Override
            public void run() {
                System.out.println("B");
                //executorService.execute(this::run);
            }
        };
        Runnable runc=new Runnable() {
            @Override
            public void run() {
                System.out.println("C");
                //executorService.execute(this::run);
            }
        };
        for(int i=0;i<10;i++){
        executorService.execute(runa);
        executorService.execute(runb);
        executorService.execute(runc);}
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package pro_cum;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LOCK {
    public static void main(String[] args) {
        Data1 data=new Data1();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printA();
            }
        }).start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printB();
            }
        }).start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printC();
            }
        }).start();
    }
}
class Data1{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num=1;

    public void printA(){
        lock.lock();
        try{
            while(num!=1){
                condition1.await();
            }
            num++;
            System.out.println("A");
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try{
            while(num!=2){
                condition2.await();
            }
            num++;
            System.out.println("B");
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try{
            while(num!=3){
                condition3.await();
            }
            num=1;
            System.out.println("C");
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

31.死锁代码