java八股之并发编程

1.java线程和操作系统线程之间的区别？

现在java线程本质上是操作系统线程，java中采用的是一对一的线程模型（一个用户线程对应一个内核进程）

2.什么是进程和线程？

1.进程是操作系统一次执行，资源分配和调度的基本单位，有独立的内存和资源，创建和销毁的开销大，进程之间相互独立
2.线程是进程内部的执行单位，是CPU调度的基本单位，可以共享进程的资源。
3.同一个进程内的线程共享堆和方法区的资源
4.每个线程都有自己的程序计数器，虚拟机栈和本地方法栈

3.程序计数器为什么是私有的？

1.程序计数器依次读取指令，实现代码的控制，用于记录当前线程执行的位置，线程切换后他才能恢复到正确的执行位置

4.虚拟机栈和本地方法栈为什么是私有的？

1.虚拟机栈：在java方法执行之前会创建一个栈帧用于存储局部变量表，操作数栈等。从方法调用到执行完成的过程，对应栈帧中入栈和出栈的过程
2.本地方法帧，功能和虚拟机栈相似，但是用到了Native方法
总结：保证线程局部变量不被别的线程访问到。

5.为什么存在JVM？

1.java程序被编译成了字节码.class文件，JVM可以在不同的操作系统或平台上运行这些字节码，不同的平台有不同的JVM实现，它屏蔽了底层操作系统和硬件的差异，使得java程序实现了“一次编写，到处运行”的特性

6.介绍下堆和方法区之间的区别？

1.堆主要用于存储对象实例和数组，是所有线程共享的。方法区存储类中的常量，静态变量等
2.堆内存的分配是动态的，当创建新的对象时候，堆就会为其分配内存空间。方法区的内存分配在类的加载时进行，当类被加载到JVM时，常量池信息就会加载到方法区

7.创建线程的方式

1.继承Thread类，实现Runnable接口和实现Callable接口

8.说说线程的生命周期和状态？

1.NEW:初始状态，线程被创建但是没有调用start()方法
2.RUNNABLE:运行状态，线程调用了start()方法
3.BLOCKED:阻塞状态，等待锁释放
4.WATING：等待状态，等待其他线程执行后
5.TIME_WATING:超时等待状态，可以在指定时间后自行返回
6.TERMINATED:终止状态，线程已运行完毕

9.什么是线程的上下文切换

1.线程在执行的过程中会有自己的运行条件和状态（上下文）。当发生线程切换的时候，如主动让出CPU，时间片用完，IO操作，这个时候需要保存上下文信息，方便下次回复现场，这就是所谓的上下文切换。

10.sleep方法和wait方法的对比

1.共同点：都可以暂停线程的执行
2.区别：sleep没有释放锁，wait释放锁。
wait一般用于线程之间的交互，sleep通常用于暂停线程的执行。wait方法需要调用notify苏醒，或者设置超时时间，sleep一般执行完成，自动苏醒

11.为什么wait方法不定义在Thread中？

wait是让获得对象锁的线程实现等待，会自动释放当前线程占有的对象锁，每个对象都有对象锁，因此操作的是对象Object而不是Thread。
sleep方式只是让当前线程暂停执行，不涉及到对象，所以在Thread中

12.可以直接调用Thread类的run方法吗？

new Thread线程进入新建状态，调用start方法进行就绪状态，等分配到时间片开始运行，自动执行run方法的内容。如果直接执行run方法，会把run方法当作main线程下的普通方法执行，并不会在线程执行

13.为什么要使用多线程？

线程是程序执行的最小单位，线程间切换的开销远小于进程。并且现在电脑都是多CPU，可以多个线程同时运行。多线程是高并发的基础，可以提升系统的并发能力

14.单核CPU支持JAVA多线程吗？

支持，单核CPU通过时间片轮转的方式分配给不同的线程使用，一个CPU一次只能执行一个任务，但可以在多个线程之间快速切换，感觉上是一起工作

15.单核CPU上运行多个线程效率一定高吗？

如果是CPU密集型，频繁的线程切换开销会导致效率降低
IO密集型，CPU可以充分利用IO等待时间，可以提高效率

16.产生死锁的必要条件

1.互斥条件：该资源任意一个时刻只能由一个线程占用
2.请求与保持条件：线程请求资源阻塞时，对持有的资源不释放
3.不剥夺条件：对于获得的资源没使用完不能被其他线程强行剥夺，只有使用完才释放资源
4.循环等待：循环等待对方手里的资源

17.如何避免死锁：

1.破坏请求和保持：一次性申请所有资源
2.破坏不剥夺：主动释放资源
3.破坏循环等待：按序分配资源

18.Synchronized和Lock区别

1,Synchronized是内置的java关键字，Lock是一个Java类
2.synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
3.Synchronized会自动释放锁，Lock必须要手动释放锁！否则死锁
4.synchronized线程1获得锁，线程2 只能傻傻的等待

19.什么叫做可重入锁

1.指的是同一个线程再持有锁的情况下，多次获取该锁不会被阻塞
2.可重入锁内部维护了一个计数器，当线程第一次获取锁时，计数器会被设置为1，如果该线程再次请求同一把锁，计数器会递增。当线程释放锁时，只有计数器的值变为0，锁才会被完全释放，此刻其他线程才有机会获得该锁。

20.如何理解生产者和消费者问题synchronized

1 判断等待—业务—通知三个流程
2.资源类和线程分开
3.多生产多消费情况下，判断要通过while循环判断，防止虚假唤醒问题，if只会执行一次

21.JUC版生产者和消费者

lock替代synchronized
condition.await替换wait,condition.signalAll()替换notify
可以精准通知线程唤醒，设置对应的同步监视器

22.8锁问题

1,synchronized锁的对象是方法的调用者，谁先调用谁就先拿到锁
2.普通方法优先于同步方法先执行
3.带了static的方法，锁的是class对象，一个类只有全局唯一的class对象

23.List线程不安全的解决方案

1. 使用vector实现类
   2.使用Collections.synchronized(new ArrrayList<>())
   3.new CopyOnWriteArrayList<>();
   4.如果不适用上述方法，可能出现CocurrentModifiationArrrayList
   5.CopyOnWriteArrayList使用lock锁，vector内部采用的是synchronized锁

24.hashset的底层是什么？

底层就是用的hashmap的key的唯一性，使得set不重复

25.多线程的第三种创建方式：实现Callable接口

psvm {MyThread thread = new MyThread();FutureTask futureTask = new FutureTask(thread);new Thread(futureTask "A").start();Integer o = (Integer)futureTask.get(); // 获取返回值sout(o);
}class MyThread implements Callable<Integer> {@overridepublic Integer call(){return 1024;}
}

把线程丢到FutureTask中，futertask丢到启动类中

26.CounterDownLatch

counterDownLatch.countDown(); //数量-1
countDownLatch.await(); // 等待计数器归零，然后再向下执行

27.CylicBarrier

CylicBarrier cylicBarrier = (new CylicBarrier(7, ()->{sout(“成功”)})
cylicBarrier.await() 计数器加一，等待线程执行结束，输出成功
类似于一个加法计数器

28.Semaphore信号量

Semaphore semaphore = new Sephore(3);
semaphore.acquire(); // 获取信号量，如果已满，等待被释放，信号量-1
semaphore.release(); // 释放信号量，信号量+1
多个共享资源的互斥使用

29.ReadWriteLock

1.写入保证原子性，必须保证有序。读线程可以随机读取，多个线程可以同时占有
独占锁（写锁）：一次只能被一个线程占有
共享锁（读锁）：多个线程同时占有

30.线程池

程序运行的本质：占用系统资源！为了优化资源的使用，引入了线程池
池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我
线程池的好处：降低资源的消耗，提高响应的速度，方便管理