direct addressing method

digital analytics

Square-Medium Method

folding method

division leaving remainder method

random number method

Linear probing and then hashing

squared probing and hashing

Huffman coding

Approximate bin packing problem

Divide and conquer algorithm running time

Recent issues

Select question

Use a table instead of recursion

The order of matrix multiplication

optimal binary search tree

The shortest path for all pairs of points

random number generator

jump table

aptitude test

Read our class file into memory

Bootstrap class loader (written in C)

Extension class loader (written in Java)

(Application) AppClassLoader class loader (written in Java)

Custom class loader (written in java)

The purpose is to prevent conflicts between the classes defined by developers and the source code classes defined by jdk, and to ensure the uniqueness of the class in memory.

Record the line number of the current thread executing code to facilitate the next CPU context switch to resume execution.

new objects are stored in the heap (shared by threads)

Troubleshooting heap memory leaks in production environment

Heap structure division

static constant pool

Run constant pool

String constant pool

The string constant pool in JDK1.6 and before is stored in the method area (permanent generation)

In JDK1.7, the string constant pool begins to be stored in the heap

The string constant pool in JDK1.8 is stored in the heap

Why did JDK1.7 start to store the string constant pool in the heap?

String s1 = "mayikt";

new String("mayikt");

A piece of memory may be divided into the Java heap as a handle pool. What is stored in the reference in the local variable is the handle address of the object.

What is stored in reference is directly the object address.

1. When the Java virtual machine encounters a bytecode new instruction, it will first check whether the parameters of this instruction can locate the symbolic reference of the class in the constant pool (in metaspace), and check the class represented by this symbolic reference. Whether it has been loaded, parsed and initialized (to determine whether the class has been loaded by the metaspace)

If not, the corresponding class loading process must be executed first (then use the parent delegation mechanism to find the class (full path of the class), if not found, an error will be reported: ClassNotFoundException).

Use if the heap memory is regular

Use if the heap memory is irregular

1. Use CAS failure retry to ensure the atomicity of updates;

2. Allocate a piece of TLAB space unique to the current thread in Eden (Eden Campus) for each thread.

Advantages: high efficiency/no moving memory addresses

Disadvantages: prone to fragmentation

Advantages: avoids fragmentation problems

Disadvantages: moving memory address, low efficiency

Advantages: avoids fragmentation problems

Disadvantages: moving memory address, high efficiency

new generation

old age

(Parallel in the new generation) ParNew (serial in the old generation) Serial old

(New generation serial) Serial, (Old generation) Serial old

(New generation serial) Serial/CMS (Old generation concurrency)

(Concurrency in the new generation) ParNew/CMS (Concurrency in the old generation)

(New generation parallel) Parallel/SerialOld (Old generation serial)

(Parallel in the new generation) Parallel Scavenge/Parallel Old (parallel in the old generation)

G1 (JDK9 default) entire heap collection

Detailed explanation of Serial garbage collector

Detailed explanation of ParNew garbage collector

Detailed explanation of Parallel garbage collector

CMS garbage collector principle (key points)

G1 collector principle (key points)

Detailed explanation of ZGC garbage collector

Detailed explanation of Epsilon and Shenandoah garbage collectors

floating garbage

Missing bid problem

Based on incremental update method (CMS)

Based on original snapshot method satb(G1)

Process is the smallest unit of resource allocation

Thread is the smallest unit of program execution

Client (mobile App/) development

Send SMS/Send Email Asynchronously

Change code that takes time to execute to multi-threaded asynchronous execution.

Write log asynchronously

Multi-threaded download

Multithreading (parallel execution)

Single thread (synchronous execution)

The current CPU switches to execute another thread

Not necessarily. Opening too many threads can easily cause CPU context switching.

initial state

ready state

Operating status

<font face="宋体"><span style="font-size: 14px;">Death state</span></font><br>

blocking state

timeout wait

waiting state

Inherit the Thread class to create a thread

Implement the Runnable interface to create a thread

Create threads using Callable and Future

Use a thread pool such as the Executor framework

Create a thread using the @Async asynchronous annotation

Create a thread using lambda expression

When multiple threads write to the same global variable at the same time, they may be interfered by other<br>threads, which may lead to thread safety issues.

lock Manually acquire and release locks

Synchronized automatically acquires and releases locks

SynchronizedJDK6 starts the automatic lock upgrade process

The underlying implementation of the lock lock is based on the aqs lock and requires manual upgrade of the lock.

How to troubleshoot deadlock with multi-threading

Causes of multi-thread deadlock threads

Synchronized solves thread safety issues

Lock lock solves thread safety problem

wait releases the current lock and blocks the current thread

notify wakes up the blocked thread

The bottom layer is based on wait encapsulation

Mark Word

Klass Pointer<br>

member properties

The size of the object must be an integer multiple of 8 bytes. If it is not an integer multiple of 8 bytes, it will be aligned and padded.

Locking and unlocking do not require additional overhead. They are only suitable for the same thread to access the synchronized code block without additional overhead. If multiple threads compete at the same time, the lock will be revoked.

Competing threads will not block, which improves program response speed. If the competing thread for the lock is never obtained, spin will be used to consume CPU resources. It is suitable for situations where synchronized code blocks execute very quickly. Spin (jdk1 .Intelligent rotation after 7)

Thread competition does not use spin, does not consume CPU resources, and is suitable for synchronous code execution for a relatively long time.

1. The current thread obtains whether it is a biased lock from the markword in the object header. If it is a biased lock, determine whether the thread's id=== the current thread id.

2. If it is equal to the current thread id, the CAS operation will not be performed repeatedly, but will directly enter our synchronization code block.

3. If it is not equal to the current thread id, if it is a lock-free situation and there are no other threads competing with me, directly use CAS to modify the lock status in markword to 101 and also store the current thread id in markword.

4. Other threads start to compete with the bias lock thread. If the number of bias lock cancellations reaches 20, they will directly redirect the bias lock to T2 thread in batches (note: there are no other threads competing with t2). If the number of bias lock cancellations reaches 20, 40 times, batch undoing will begin later.

5. To cancel the biased lock, we need to stop our biased lock thread at a global safe point, modify our markword to a lightweight lock, and wake up the biased lock thread.

6. Note: JDK15 turns off biased lock optimization by default.

1. If multiple threads compete for the same lock at the same time, upgrade the lightweight lock and use CAS (modify markword lock status = 00). If successful, replace it with markword and store the HashCode value directly in our stack frame. Currently, The lock record address is stored in markword

2. When we use a lightweight lock to release the lock, the markword value content is restored

1. If our thread has retried multiple times and still has not acquired the lock, the current lock will be upgraded to a heavyweight lock.

2.2. Threads that have not acquired the lock will be stored in the C Monitor object EntryList collection. At the same time, the current thread will directly block and release the cpu execution rights. The process cost of waking up and re-entering the competition lock in the later period is very high because cpu context switching needs to occur. Switch from user mode to kernel and change the markword value in our object header to C Monitor. The memory address pointer Java object is associated with C Monitor.

recursions (number of recursions/number of reentries)

owner (records the thread ID currently holding the lock)

waitSet (threads waiting for the pool to be in wait state will be added to _WaitSet)

entryList (lock pool: threads waiting for the lock block state will be added to the list)

After the thread in the waiting pool is awakened, the waiting pool is transferred to the lock pool and queued to compete for the lock again.

Each thread holds the lock for as short a time as possible

Lock elimination is a lock optimization method that occurs at the compiler level

State state value

Node status(waitStatus)

Fair lock and unfair lock

Core design principles

There is no lock upgrade process in the lock, and developers need to expand it themselves.

Note: Condition and lock do not use the same doubly linked list

Lock pool and wait pool

How to wake up the thread in the waiting pool?

Through the constructor new CountDownLatch(1)

await method

countDown

Through the constructor new Semaphore(3)

The underlying operation of acquire is to modify the status value -1 in the AQS class. If the status value in the AQS class is changed to 0, the current thread needs to be blocked and stored in the doubly linked list in the AQS class.

The bottom layer of release operates on the status 1 in the AQS class<br>

Through constructor new CyclicBarrier(2)<br>

Call await bottom layer

AbortPolicy discards tasks and throws runtime exceptions

CallerRunsPolicy execution task

DiscardPolicy Ignore, nothing will happen

DiscardOldestPolicy kicks from the queue and enters the queue first.

Implement the RejectedExecutionHandler interface and customize the processor

Optimal number of threads = number of cpu cores or number of cpu cores ±1

Optimal number of threads = ((thread waiting time thread CPU time)/thread CPU time) * number of CPUs

What if the service does go down?

Nacos service registration and discovery source code interpretation

Naocs service heartbeat detection and renewal source code interpretation

Naocs service offline and health check source code interpretation

Nacos cluster Raft election algorithm source code interpretation

Nacos server long polling processing mechanism

Principle of data synchronization between Nacos cluster nodes

Implementation principle of Nacos distributed configuration center

How to dynamically refresh configuration files in Nacos

Specify time rule matching route

cookie matching route

Header matching route

Host matching route

Request method matching route

Request path matching route

Custom GatewayFilter

Gateway integrates Nacos to achieve load balancing

Gateway integrates Sentinel to implement gateway current limiting

MySQL master-slave replication principle architecture analysis

How Canal pretends to subscribe to BinLog files from nodes

Design principles of EventParser and EventSink

Canal incremental subscription/consumption design principle

How to reduce the latency of synchronization between data

How to avoid data synchronization message sequence consistency

How to avoid data synchronization loss problem

token bucket

leaky bucket

Fixed counting window

sliding technology window

Threads

QPS

Flow control rules

Google Guava(RateLimiter)

Alibaba Sentinel

Nginx

Redis lua implements current limiting

It is recommended that current limiting be done on nginx or gateway

Array linked list

Head insertion method (concurrent expansion infinite loop problem)

Code writing is simple

Array linked list red black tree

tail insertion method

High-end code writing

Red-black tree conversion

(h = key.hashCode()) ^ (h >>> 16)

i = (n - 1) & hash

Key does not conflict

Key conflict

hashcode collision problem

The key is null to store the 0 position of the array.

Implemented using a one-way linked list

Unordered hash storage

data structure

Lock implementation

Capacity expansion implementation

data structure

Lock implementation

Capacity expansion implementation

array

Subscript query time complexity o(1)

The expansion is 1.5 times the original

The addition and deletion efficiency is low and requires expansion, but the query efficiency is relatively high.

array

Subscript query time complexity o(1)

The expansion is 2 times the original

linked list

Subscript query time complexity log2(n) binary search

The efficiency of addition, deletion and modification is high, but the query efficiency is relatively low.

When the business execution time is very long, it is recommended to use mq asynchronous instead.

retry policy

Query in advance whether the business logic has been executed based on the global ID

insert type unique annotation constraint

update type optimistic locking mechanism

Suitable for business execution very fast

How to avoid deadlock problems when continuing life

Consider the herd effect

Set blocking timeout

Lock granularity reduced

main idea

Two implementation methods

Curator framework distributed lock

Interview difficulties

main idea

Redisson framework

Interview difficulties

jta Atomikos solves distributed transactions

In the cluster, the copy data of each node must be consistent

In the cluster, some node replicas are allowed to have inconsistent data

Short data delays are allowed, but eventually data consistency is required

Base theory

CAP

Rigid transactions satisfy ACID theory

Flexible transactions satisfy BASE theory (basically available, eventually consistent)

Advantages: low latency

Disadvantages: Not decoupled

Advantages: Implement decoupling, retry compensation strategy, improve interface response

Disadvantages: high latency

Advantages: More decoupling, retry compensation strategy, improved interface response

Disadvantages: Latency is getting higher and higher

Need to delay double deletion, delete twice

It needs to be combined with mq and ensure message sequence consistency. Deleting the cache must be successful.

What is double writing

What problems will arise

How to solve dirty reads

1.canal disguises itself as a mysql slave node and subscribes to the binlog file of the mysql master node;

2. When the binlog file of our mysql master node changes, the binlog file<br> is sent to the canal server;

3. The canal server converts the binlog file into json format and sends it to the canal client;

4. The canal client synchronizes the data to Redis/ES;

tcp (low efficiency)

kafka (recommended)

Integrate MQ topic mode

How to solve the message sequence consistency problem

During the data synchronization process, there will be a short delay, which is normal. It is difficult to achieve strong consistency and follow the idea of ​​eventual consistency.

Rabbitmq management platform center

Virtual Hosts

Exchange

routing key

simple mode<br>

work mode

Broadcast mode---fanout

Routing mode --direct

Theme mode--topic

Direct exchange (direct switch)

Fanout exchange

Topic exchange

Headers exchange

How RabbitMQ ensures messages are not lost

RabbitMQ dead letter queue

RabbitMQ message automatic retry mechanism

Broker (MQ server side)

Topic (topics are classified according to business)

Partiiton (partition storage message)

Producer

Consumer

Consumer Group

Replica (replica mechanism)

Offset (consumption record)

storage structure level

java application level

linux kernel level

Replication

Producer delivers message ack

Kafka election principle controller principle

Consumer manually submits offset

1. Search Segment segment files based on offset (binary search)

2. Access the index file (sparse index) and find the corresponding physical storage location

3. According to the physical access location, access the log to find the physical corresponding message.

producer

consumer

Broker (MQ server side)

Built-in query cache

Grammar and lexical parsing

semantic processor

Optimizer/execution plan

query execution engine

InnoDb memory structure and disk structure

Buffer design

linux

windows

Initialization module

Core API

Network interaction module

Client & Server interaction protocol module

user module

access control module

Connection management, connection threads and thread management

Query parsing and forwarding module

Query optimizer module

Logging module

Storage engine interface module

hash table

binary search tree

red black tree

Balanced multi-fork search tree

B Trees

Full text index

primary key index

combined index

unique index

repeatable read

read commit

Read uncommitted

serialization

Row lock, table lock, page lock

Pessimistic lock/optimistic lock

Gap Lock

Deadlock analysis principle

How to enable MySQL slow query

id: The larger the column, the higher the execution priority. If the id is the same, it will be executed from top to bottom. If the id is NULL, it will be executed last.

select_type: indicates the type of query

table:explain which table is being accessed by a row.

type column

Extra means additional information

Follow the best left prefix rule to prevent index failure

Try to use covering indexes to avoid table back queries

Sorting follows the best left prefix method to avoid filesort

The minimum type satisfies the range range query level

Pagination optimization where id condition filters offSet or subquery locates id association

Join table query optimizes small tables to drive large table data. It is prohibited to use join for more than three tables.

Like fuzzy follows the best left prefix rule or use composite index fuzzy query

The time complexity is O(n), and there are certain restrictions on monitoring file descriptors.

The time complexity is O(n), and there is no limit on listening to file descriptors.

The time complexity is O(1), and there is no limit on listening to file descriptors.

MMAP write

Sendfile

Things to think about:

Single Reactor single thread

Single Reactor multi-threading

Reactor master-slave model

When the session is saved on the jvm server, the node cluster synchronization issue needs to be considered.

Implementation principle

Advantages and Disadvantages

components

Advantages and Disadvantages

How to implement logout in Jwt

Use multi-threading to process emails, text messages, and coupons sent after login, thereby improving interface response efficiency.

Large projects use mq asynchronous and time-consuming processing to reduce server CPU resources.

web form

Separation of front and back ends

By setting the user’s real IP in nginx

Use jsonp but does not support post requests (not recommended)

Use SpringMVC @CrossOrigin annotation (recommended)

Solve cross-domain problems based on gateway (recommended)

Access based on different projects based on Nginx (recommended)

1. Generate authorization link address based on appid

2. Obtain authorization code

3. Obtain the accessToken based on the authorization code

4. Obtain user information based on authorization code

RSA asymmetric encryption

MD5

Synchronous callback

Asynchronous callback

The synchronous callback jumps in the form of a browser and does not modify the order status.

After the asynchronous callback verifies the signature successfully, pay attention to the idempotent issue to modify the order status.

The same order number is submitted from the form to third-party payment, and the third-party payment will ensure global uniqueness based on the order number.

This phenomenon is normal. Through the idea of ​​eventual consistency, you can actively call the Alipay interface to query whether the order has been<br>paid.

In the asynchronous callback, it will be queried based on the order whether the user's real order number is consistent with the user's payment amount<br>If they are inconsistent, it is an abnormal order.

Direct storage of integer types can later be converted into elements

decimal type

1. Set the timeout for redirecting Alipay orders to 30 minutes

2. The delay queue actively calls the Alipay interface to check the payment status based on the order number around 31-35 minutes.

3. If the payment is still not made after calling the Alipay interface, the order will be considered time-consuming.

Optimization

final effect

Optimization

final effect

Use docker or K8S to elastically expand/shrink deployment

Numeric type

non-numeric type

class

interface

array[]

Parametric constructor injected properties

p namespace injection

Inject null values ​​and special symbols

Inject internal beans

Inject external beans

Inject cascade assignment

Inject collection type properties

SpringBean life cycle

SpringBean scope

SpringBean automatic wiring

SpringBean external property file

SpringBean annotation startup method

SpringBean's annotation startup function

SpringBean annotation scanning configuration

Autowired and Qualifier annotations

@Resource usage

AOP basic concepts

The basic role of AOP

Static proxy and dynamic proxy

@AspectJ annotation usage

Use aop to print logs uniformly

Classification of transactions

Seven communication behaviors of affairs

Can help developers quickly integrate third-party frameworks (Principle: Maven dependency encapsulation)

Remove xml configuration and completely use annotation (principle: built-in annotation method in Spring system)

No need for external Tomcat and internal implementation server (principle: Java language supports embedded Tomcat server)

SpringCloud dependencies and SpringBoot components

Use SpringMVC to write Http protocol interface

Spring Cloud is a complete microservice solution framework

spring-boot-start-parent,

spring-boot-starter-web

All methods of Controller return JSON format

@EnableAutoConfiguration

@ComponentScan

@SpringBootApplication

What template engine framework

Integrate ftl template engine

Integrate thymeleaf template engine

JdbcTemplate

mybatis

hibernate

Integrate devtools tools

Integrate lombok

Use @value annotation to read configuration files

Properties convert yml format

@ConfigurationProperties

Configuration file placeholder usage

Integrate different configuration files in multiple environments

Modify port and context path

logback

log4j

Use aop to print log information uniformly

Integrate scheduled tasks @Scheduled annotation

Timed integration tasks combined with Quartz expressions

Pay attention to @Async invalidation problem

@Async integrates thread pool

Why do you need to use docker

Benefits of using docker

The difference between containers and virtual machines

Install docker in Linux environment

Install docker in Win environment

Image file

container

storehouse

Docker download image principle

Docker image loading principle

Cloud accelerated image configuration

docker --help (help command)

docker --version (view version)

docker images (view images)

docker search (search image)

docker pull (download image)

docker container

Docker Commit (made into an image file based on the current container)

Tomcat

Nginx

MySQL

DockerFile writing specifications

DockerFile directive

Build springboot project based on Dockerfile

Compose common commands

Compose template file

Portainer

DockerUI

microservices

devops

continuous delivery

Containerization