Skip to content

Commit 3a9c933

Browse files
coding-technologycoding-technology
committed
init
0 parents  commit 3a9c933

6 files changed

Lines changed: 535 additions & 0 deletions

File tree

‎.gitignore‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
.idea/
2+
*.iml

‎README.md‎

Whitespace-only changes.

‎docs/day01.md‎

Lines changed: 175 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,175 @@
1+
#〇.技术面试指导
2+
-------（必须）--------
3+
0.自我介绍
4+
表达流畅，不要太差即可
5+
6+
1.基础
7+
自己百度常见面试题（不含答案）
8+
坑：【答案很标准】
9+
面试题的答案：一定不要背标准答案，一定要有自己的思想 (哪怕有少量错误)
10+
常见的题，一定要会： arraylist/hashmap的源码、实现源码 ，冒泡排序/快速排序、 单例模式/工厂模式/动态工厂、谈谈你对面向对象的理解， 事务ACID/隔离级别 ，Spring IOC/AOP
11+
12+
建议： 自己的理解 -> 搜博客/githug上搜大神的博文、理解 。可以将 面试题中的问题 在博客、github上搜答案，不要在面试题附带的答案上搜
13+
坑：不要写“精通”
14+
建议：掌握、熟练 ,理解 ，会使用
15+
16+
2.技术列表
17+
不要中规中矩:培训/看某套视频出来的
18+
java + 数据库+web前端+jsp/servlet+ssm +boot/cloud+ 2-3非培训机构标配课程(只要掌握该技术的1-2个核心点即可)
19+
-> 缺失个人独立思考的能力
20+
坑： 技术点，宁可少写，也别多写， 写多了可能是坑
21+
一般而言：简历上写到的技术，很可能被问到
22+
23+
3.项目
24+
坑：电商、管理系统 ->培训机构标配，缺乏真实项目的感觉
25+
建议：
26+
（1）.提前准备好回答的台词
27+
（2）.技术本身的不足，如何弥补 -》技术、真实性
28+
a.mysql、大型、海量 ： 如果数据超过的Mysql的容量怎么处理？
29+
b.高并发项目，缓存： 在哪些场景 见过缓存失效？怎么解决？
30+
c.MQ解决耦合性：哪些真实的场景 用到 解耦合？
31+
（3）项目的重难点
32+
a.分布式项目： 如何共享数据
33+
b.高并发： 几级缓存，如何限流，如何熔断
34+
（4）真实性：实际的使用场景
35+
a.“用到的人脸识别技术” ： 哪些场景用到了
36+
b.多线程、设计模式、算法： 处理什么业务？场景？
37+
c.大数据的项目？ 数据从哪来？
38+
d.如何设计表？外键 一对一 一对多如何
39+
e.项目能否访问？
40+
（5）描述：技术+文字 ， 项目周期：半年以上 ， 写几个？ 3以内 ： 2-3 毕业：1-2
41+
42+
4.表达沟通能力
43+
44+
-----加分-------
45+
1.高并发/分布式
46+
a.多线程（juc,aqs,线程安全，锁机制，生产消费者）
47+
b.数据处理
48+
SQL优化 ， mysql+mycat+haproxy+keepalived
49+
50+
2.实际的解决问题能力
51+
主动引入
52+
回答项目： 遇到过什么问题、如何发现、排查、分析、解决、总结
53+
主动、学习、能发现问题、解决
54+
55+
3.绝杀：
56+
ACM竞赛、蓝桥杯等全国性竞赛、出版
57+
github发布一个项目(star很多) 、 博客、公众号、
58+
个人已发布的项目（阿里云）、牛人推荐信 、JDK/spring/mybatis源码
59+
（电子简历：链接 纸质：二维码）
60+
61+
62+
----注意/建议事项----
63+
1.体现数字： 几个项目、几篇博客 、排名第几
64+
2.工作：不要面议 ， 范围5000-8000
65+
3.简历： 1-2页（尽量不要空半页），不要书皮，格式PDF（wps word，可能出现兼容问题）, 外观不要太过绚丽
66+
4.细节： 毕业时间、年龄、工作履历、期望薪资
67+
68+
沟通：注意人文素养 ,不要抱怨问题， 要体现解决问题
69+
建议： 个人解决的能力、团队、沟通
70+
71+
72+
#一.重载和重写的区别
73+
74+
| | 方法名 | 参数列表 | 返回值 | 访问修饰符 | 抛出异常|
75+
|- | - | - | - | - | -|
76+
|方法重写 | 相同 | 相同 | 相同或是其子类 | 不能比父类更严格 | 不能比父类更宽泛|
77+
|方法重载 |相同 | 不相同 | 无关 | 无关 | 无关|
78+
79+
80+
81+
#二.常见集合框架的底层数据结构
82+
83+
题外话1：List和Set的上级接口是Collection，但Collection与Map之间不存在继承/实现关系。
84+
题外话2：本文中的是否“唯一”，是指集合中的元素值是否可以重复。
85+
有序/无序，是指输入集合的顺序 是否和 集合的存储顺序一致（或理解为输出顺序），例如，向集合依次输入a、b、c后，如果打印时也输出a、b、c就代表“有序”；如果打印时输出的是a、c、b（或b、a、c等）就代表“无序”。
86+
87+
Collection(不唯一、无序)
88+
##1List(不唯一、有序)
89+
- Arraylist： 线程不安全，Object数组 ，默认长度是10。
90+
扩容机制：当超过数组容量时，新数组是原来数组的1.5倍。JDK中的源码是：
91+
```
92+
private void grow(int minCapacity)
93+
{
94+
...
95+
int newCapacity = oldCapacity + (oldCapacity >> 1);
96+
}
97+
```
98+
- Vector： 线程安全，Object数组，默认长度是10。
99+
扩容机制：当超过数组容量时，新数组是原来数组的2倍。JDK中的源码是：
100+
```
101+
private void grow(int minCapacity) {
102+
...
103+
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
104+
capacityIncrement : oldCapacity);
105+
```
106+
107+
LinkedList： 双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环) 。通过first和last引用分别指向链表的第一个和最后一个元素（元素用Node表示），Node的源码如下所示。
108+
109+
```
110+
111+
private static class Node<E> {
112+
E item;
113+
Node<E> next;//下一个
114+
Node<E> prev;//上一个
115+
116+
Node(Node<E> prev, E element, Node<E> next) {
117+
this.item = element;
118+
this.next = next;
119+
this.prev = prev;
120+
}
121+
}
122+
```
123+
124+
##2Set
125+
HashSet（唯一，无序）: 线程不安全，基于HashMap实现的，底层采用 HashMap 来保存元素
126+
LinkedHashSet： LinkedHashSet继承自HashSet，并且其内部是通过 LinkedHashMap来实现的。
127+
TreeSet（有序，唯一）： 红黑树
128+
129+
##3Map（以key-value形式存储数据，通过key取value。key不能重复，value可以重复。）
130+
HashMap：线程不安全，通过ConcurrentHashMap解决。JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体（默认初始容量为16），数组中的每个元素是链表的形式。JDK1.8以后，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。 HashMap的加载因子为0.75：当元素个数 超过 容量长度的0.75倍 时，进行扩容。扩容增量：原容量的2倍.
131+
LinkedHashMap: LinkedHashMap 继承自HashMap。LinkedHashMap在上面结构的基础上，增加了一条双向链表，使得HashMap的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。
132+
HashTable: 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
133+
TreeMap: 红黑树
134+
ConcurrentHashMap：JDK8以前的ConcurrentHashMap间接的实现了Map<K,V>，并将每一个元素称为一个segment（默认16个），每个segment都是一个HashEntry<K,V>数组，数组的每个元素都是一个HashEntry的单向队列。JDK8以后，HashMap/ConcurrentHashMap的存储结构发生了改变：增加了条件性的“红黑树”。为了优化查询，当链表中的元素超过 8 个时，HashMap就会将该链表转换为红黑树，即采用了数组+链表/红黑树的存储结构。
135+
136+
#三.Arraylist 与 LinkedList 异同
137+
**（1）是否保证线程安全**： ArrayList 和 LinkedList 都是线程不安全；
138+
**（2）底层数据结构**： Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向链表数据结构（JDK1.6之前为循环链表，JDK1.7取消了循环）
139+
**（3）插入和删除是否受元素位置的影响**：
140+
*ArrayList* 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行add(E e) 方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（ add(int index, E element) ）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
141+
*LinkedList*采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O(1)而数组为近似 O(n)。
142+
**（4）是否支持快速随机访问**： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index) 方法)。
143+
**（5）内存空间占用**： ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。
144+
145+
146+
#四.试述Forward和Redirect的区别
147+
**（1）转发（Forword）是服务器行为，重定向（Redirect）是客户端行为**
148+
**转发**可以通过HttpServletRequest对象的getRequestDispatcher()方法链式调用forward()方法实现，如request.getRequestDispatcher().forward()。
149+
**重定向**是利用服务器返回的状态吗来实现的。客户端浏览器请求服务器的时候，服务器会返回一个状态码。服务器通过HttpServletRequestResponse的setStatus(int status)方法设置状态码。如果服务器返回301或者302，则浏览器会到新的网址重新请求该资源。转发可以通过HttpServletResponse对象的sendRedirect()方法实现。
150+
**（2）地址栏显示**: 转发是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来, 然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址. 重定向是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
151+
**（3）数据共享**: 转发:转发页面和转发到的页面可以共享request里面的数据. 重定向:不能共享数据
152+
**（4）实际运用**: 转发:一般用于用户登陆的时候,根据角色转发到相应的模块. 重定向:一般用于用户注销登陆时返回主页面和跳转到其它的网站等
153+
**（5）效率**： 转发:高. 重定向:低.
154+
155+
#五.如何设计一个秒杀系统？
156+
157+
什么秒杀： 流量很大，库存少
158+
159+
**架构设计原则：**
160+
限流、缓存、隔离、降级和熔断
161+
162+
1.限流（多重）:尽量上级限流，负载 ,MQ流量削峰
163+
164+
2.缓存（多级）:请求->redis->DB
165+
166+
3.隔离：将秒杀的服务器隔离开
167+
168+
4.降级和熔断：
169+
熔断：客户端 -> service() , beiYong(){return "未响应，请重试"}
170+
降级：服务端 ： 20个服务->减少到10个服务
171+
172+
173+
防止重复消费行为：幂等性
174+
zs ：支付->支付服务(扣款)->返回（支付成功）
175+
幂等性实现：去重表，在每次支付前，先查看去重表中 是否有扣款记录。如果有，则返回文字提示“已扣款，请稍等响应页面”；如果没有，再执行扣款

‎docs/day02.md‎

Lines changed: 196 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,196 @@
1+
#1.简述nginx
2+
Nginx是一款轻量级的web服务器（反向代理服务器，负载均衡服务器，动静分离服务器）。
3+
（1）反向代理
4+
a.正向代理(vpn)：为客户端做代理，相当于客户端中介。代理客户端去访问服务器。
5+
（客户端->正向代理）->服务器，例如，（用户->VPN）->google，VPN就是用户的正向代理。
6+
7+
b.反向代理(nginx/apache):为服务器做代理，相当于服务端中介，代理服务器接受客户端请求。
8+
客户端-> (反向代理->服务端) ,就如，客户端 -> (nginx-> tomcat)，nginx就是tomcat的反向代理服务器。
9+
10+
假设：买房的人是客户端，卖方的人是服务端：
11+
zs想买房,zs找了一个朋友ls帮忙去买，那么ls就是zs的正向代理服务区），(zs->ls)->卖房方
12+
zl有一套房打算卖掉，zl找了一个朋友sq去卖，那么sq就是反向代理服务器，买房方->（sq->zl）
13+
14+
（2）负载均衡：分流客户端请求，均衡集群服务端压力。 Nginx支持的weight轮询（默认）、ip_hash、fair、url_hash四种负载均衡调度算法。
15+
（3）动静分离：分离静态请求和动态请求，将动态请求发送给web服务器，并给静态请求做缓存（或cdn加速）。
16+
客户端请求 -> 静态请求/动态请求
17+
静态请求：静态缓存/cdn加速
18+
动态请求: tomcat（web服务器）
19+
20+
Nginx优点：
21+
（1）高并发连接： 官方测试Nginx能够支撑5万并发连接，实际生产环境中可以支撑2~4万并发连接数。
22+
（2）Nginx为开源软件，成本低廉
23+
（3）稳定性高：用于反向代理时，非常稳定
24+
（4）支持热部署能够在不间断服务的情况下，进行维护。
25+
26+
#2.两种以上方法实现“多线程交替打印123123123...”
27+
建立三个线程，第一个线程打印1、第二个线程打印2、第三个线程打印3；要求三个线程交替打印，123123123123……
28+
**方法一**
29+
30+
```
31+
package interview;
32+
import java.util.concurrent.locks.Condition;
33+
import java.util.concurrent.locks.Lock;
34+
import java.util.concurrent.locks.ReentrantLock;
35+
//多线程交替打印123123123...（两种以上方法实现）
36+
锁方式一： lock.lock();/unlock() : await() signal()
37+
锁方式二： synchronized :wait() notify
38+
public class LoopPrint {
39+
int num = 1;
40+
//只有一个变量，因此只需要一把锁。但需要通知三个线程，因此需要三个“条件通知”
41+
Lock lock = new ReentrantLock();//一把锁
42+
//三个线程 的通知
43+
Condition condition1 = lock.newCondition();//通知线程1打印
44+
Condition condition2 = lock.newCondition();
45+
Condition condition3 = lock.newCondition();
46+
/*
47+
num : 打印的数字1/2/3
48+
线程1： 判断num是否为1，如果不是，则等待；如果是，则打印，打印完后 [通知]线程2
49+
线程2：判断num是否为2，如果不是，则等待；如果是，则打印，打印完后 [通知]线程3
50+
线程3：判断num是否为3，如果不是，则等待；如果是，则打印，打印完后 [通知]线程1
51+
123123123...
52+
*/
53+
public static void main(String[] args) {
54+
LoopPrint print = new LoopPrint() ;
55+
//打印1的线程
56+
new Thread( ()-> {
57+
while(true){
58+
print.print1();
59+
}
60+
} ).start(); //lambda表达式
61+
62+
//打印2的线程
63+
new Thread( ()-> {
64+
while(true){
65+
print.print2();
66+
}
67+
} ).start();; //lambda表达式
68+
//打印3的线程
69+
new Thread( ()-> {
70+
while(true){
71+
print.print3();
72+
}
73+
} ).start();; //lambda表达式
74+
}
75+
76+
77+
//打印“1”
78+
public void print1() {
79+
//a b c -> num
80+
lock.lock();
81+
try {
82+
//线程1： 判断num是否为1，如果不是，则等待；如果是，则打印，打印完后 [通知]线程2
83+
if (num != 1) {
84+
condition1.await();
85+
}
86+
System.out.println(1);
87+
num = 2 ;
88+
//通知线程2
89+
condition2.signal(); // signal()相当于notify() ,await()相当于wait()
90+
}catch (Exception e){
91+
System.out.println(e);
92+
}finally {
93+
lock.unlock();
94+
}
95+
}
96+
97+
//打印“2”
98+
public void print2() {
99+
//a b c -> num
100+
lock.lock();
101+
try {
102+
if (num != 2) {
103+
condition2.await();
104+
}
105+
System.out.println(2);
106+
num =3 ;
107+
//通知线程3
108+
condition3.signal(); // signal()相当于notify() ,await()相当于wait()
109+
}catch (Exception e){
110+
System.out.println(e);
111+
}finally {
112+
lock.unlock();
113+
}
114+
}
115+
116+
public void print3() {
117+
//a b c -> num
118+
lock.lock();
119+
try {
120+
if (num != 3) {
121+
condition3.await();
122+
}
123+
System.out.println(3);
124+
num = 1;
125+
//通知线程1
126+
condition1.signal(); // signal()相当于notify() ,await()相当于wait()
127+
}catch (Exception e){
128+
System.out.println(e);
129+
}finally {
130+
lock.unlock();
131+
}
132+
}
133+
}
134+
135+
136+
```
137+
**方法二**
138+
```
139+
package interview;
140+
141+
import java.util.concurrent.Semaphore;
142+
143+
public class SemaphoreDemo {
144+
//1 2 3
145+
//三个信号量
146+
Semaphore sem1 = new Semaphore(1);
147+
Semaphore sem2 = new Semaphore(0);
148+
Semaphore sem3 = new Semaphore(0);
149+
150+
public static void main(String[] args) {
151+
SemaphoreDemo sem = new SemaphoreDemo();
152+
153+
new Thread( ()-> sem.print1() ).start();
154+
new Thread( ()-> sem.print2() ).start();
155+
new Thread( ()-> sem.print3() ).start();
156+
157+
}
158+
159+
160+
public void print1(){
161+
print("1",sem1,sem2 ) ;
162+
}
163+
164+
public void print2(){
165+
print("2",sem2,sem3 ) ;
166+
}
167+
168+
public void print3(){
169+
print("3",sem3,sem1 ) ;
170+
}
171+
/*
172+
value:当前值 1 2 3？
173+
current:当前谁用于许可证
174+
next：下一个谁那许可证
175+
*/
176+
private void print(String value , Semaphore current,Semaphore next ){
177+
while(true){
178+
try {
179+
current.acquire();//当前信号量 获取许可证
180+
System.out.println( Thread.currentThread().getName()+"***"+ value);
181+
Thread.sleep(1000);
182+
next.release();//将许可证传递给下一个
183+
184+
} catch (InterruptedException e) {
185+
e.printStackTrace();
186+
}
187+
188+
}
189+
}
190+
}
191+
192+
```
193+
194+
#3.基础
195+
一个".java"源文件中是否可以包括多个类？
196+
可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。此外，类中还可以包含内部类。

0 commit comments

Comments
 (0)