javac compilation directive

Javap decompilation instructions

Preparation: Various checks are required for each execution

Compatibility: Other languages ​​can also be parsed into bytecode

A small memory space, which is the line number indicator of the bytecode executed by the current thread (bytecode instructions, branches, loops, jumps, exception handling and other information)

Each thread must have an independent program counter. This type of memory is also called "thread-private" memory.

Thread private, the method will create a stack frame data structure when executed.

Mainly used to store local variable tables, operation stacks, dynamic links, method exports, etc.

When each thread is created, the JVM will create a corresponding virtual machine stack for it.

The size of the stack memory division directly determines how many threads a JVM process can create.

The difference between MetaSpace and permanent generation (before PermGen JDK7 version)

Advantages of MetaSpace compared to PermGen

The allocation area of ​​the object instance

static storage

stack storage

Heap storage

Contact: When referencing an object or array, the variable defined in the stack stores the first address of the target in the heap.

the difference

PermGen

Meta Space

The process from class compilation to execution

What is ClassLoader

ClassLoader types (four types)

Full GC is slower than Major GC, but executes less frequently

Trigger Full GC condition

When an object is created, memory allocation first occurs in the young generation

Objects are no longer used soon after they are created, and most of them are quickly cleaned up by the young generation GC.

Large objects can be created directly in the old generation

If an object survives long enough in the young generation without being cleaned up, it is copied to the old generation.

The space in the old generation is generally larger than that in the young generation and can store more objects.

When there is insufficient memory in the old generation, Full GC will be executed.

Refers to the permanent storage area of ​​​​the memory, which mainly stores Class and Meta (metadata) information.

Class is put into the permanent area when it is loaded, and the GC will not clean up the permanent generation area.

The permanent generation area will fill up as the number of loaded Classes increases, and eventually an OOM (Out of Memory) exception will be thrown.

In Java 8, the permanent generation has been removed and replaced by an area called the "metadata area" (metaspace).

The metaspace is not located in the virtual machine, but uses local memory.

Mark first, then clear, without moving the object The advantage is that it executes quickly The disadvantage is that it will cause memory fragmentation. When a large object needs to be allocated, a large enough contiguous memory cannot be found, triggering another GC.

Divided into object surface and free surface

Avoid memory discontinuities

No need to set up two swaps

Suitable for scenarios with high object survival rate

Suitable for the elderly

A combination of garbage collection algorithms

According to the different life cycles of objects, different garbage collection algorithms are used to divide different areas.

Purpose: Improve JVM recycling efficiency

reference counting

accessibility analysis

Memory space division Eden district Two Survivor zones

How to promote an object to the old generation

Commonly used tuning parameters

The JVM stopped the execution of the program due to the execution of GC.

Happens in any GC algorithm

Most GC optimizations improve program performance by reducing the time that Stop-the-World occurs.

Points where object reference relationships will not change during the analysis process

Where Savepoint is generated: method invocation, loop breakout, exception jump, etc.

Select the safe point appropriately. Selecting too few will make the GC wait time too long. Selecting too many will increase the load of the running program.

Server

Client

The relationship between garbage collectors

Serial collector (-XX:UseSerialGC, copy algorithm)

ParNew collector (-XX: UseParNewGC, copy algorithm)

Parallel Scavenge collector (-XX:UseParallelGC, copy algorithm)

Adaptive adjustment policy (-XX:UseAdaptiveSizePolicy)

Multi-threading, throughput first

The garbage collection thread can work almost at the same time as the worker thread, almost, not completely, shortening the pause time as much as possible

Initialization tag: Stop-the-World

Concurrency mark: Concurrent traceback mark, the program will not pause

Concurrency pre-cleanup: Find objects promoted from the young generation to the old generation during the concurrent marking phase

Remark: Pause the virtual machine and scan the CMS heap for remaining objects

Concurrent cleanup: The garbage collection thread executes concurrently with the user thread to clean up marked garbage.

Concurrency reset: Reset the data structure of the CMS collector

CMS collector execution process

three color marking method

Features of Garbage First collector

Divide the entire Java memory into multiple regions of equal size

The young generation and the old generation are no longer physically separated

Control the pause time very precisely to achieve low-pause garbage collection without sacrificing throughput.

To avoid full-area garbage collection, it divides the heap memory into several independent areas of fixed size and tracks the progress of garbage collection in these areas.

Based on mark-compact algorithm, no memory fragmentation occurs.

Unlike C's destructor, whose call is deterministic, its call is undefined.

Place unreferenced objects in the F-Queue queue

Method execution may be terminated at any time

Give an exclusive last chance to rebirth

Strong Reference

Soft Reference

Weak Reference

PhantomReference

ReferenceQueue

1. Bourne Shell: Developed by Bell Labs.​

2. BASH: It is GNU's Bourne Again Shell. It is the default shell on the GNU operating system. Most Linux distribution packages use this shell.

3. Korn Shell: It is a development of Bourne SHell and is compatible with Bourne Shell in most aspects.​​

4. C Shell: It is the BSD version of SUN Company Shell.

Request type

http request

The composition of http response

Redirect (page jump)

Forward (page jump)

The difference between Cookie and Session

Signatures and certificates

SSL digital certificate

Authentication steps

SSL/TLS

SSL technology

communication process

Encryption

HTTPS data transfer process

The difference between HTTP and HTTPS

Is HTTPS really secure?

The TCP/IP model includes hundreds of interrelated protocols such as TCP, IP, UDP, Telnet, FTP, and SMTP.

Among them, TCP and IP are the two most commonly used underlying protocols.

Introduction to UDP

Differences between TCP and UDP

RTT and RTO

The TCP/IP protocol is used to transport stream format sockets. TCP is used to ensure the correctness of the data. IP is used to control how the data reaches the destination from the source.

The HTTP protocol is based on connection-oriented sockets, because the data must be accurate

The return value of socket in UNIX/Linux is the file descriptor, and ordinary file operation functions can be used to transmit data.

Windows treats the socket as a network connection and needs to call the data transfer function specially designed for the socket.

Internet socket

Unix socket (pathname of local node)

X.25 socket (CCITT X.25 address)

three handshakes

four handshakes

Broken link

Data sticky package

High and low bits (big endian and little endian)

not real-time

Soft real-time

hard real time

windows, MaxOS, Linux, UNIX

Dependency Injection (DI)

Declarative programming based on aspects and inertia

Reduce boilerplate code with aspects and templates

Application scenarios

Lightweight and minimally intrusive programming based on POJOs

high level view

Container interface

Simple components can be configured and combined into complex applications

In Spring, application objects are composed declaratively, typically in an XML file

Provides many basic functions (transaction management, persistence framework integration, etc.), leaving the development of application logic to developers

Provides creation of IOC container objects and processing of dependent object relationships

core

core container

How IOC Inversion of Control is Implemented

Spring Web module

data access

test

JPA

Redis

MongoDB

Couchbase

Cassandra

ElasticSearch

Neo4j

…

OAuth2.0

CAS

WEB security

Authorize

Authentication

encryption

…

Spring provides aspect-oriented programming, which can provide transaction management for a certain layer, such as adding transaction control to the Service layer.

Provides a meaningful exception hierarchy for the JDBC DAO abstraction layer

Plugged into multiple ORM frameworks, including JDO, Hibernate and iBatis SQL Map

Support for J2EE development specifications, including enterprise services such as JNDl, EJB, electronic components, internationalization, verification and scheduling functions

Spring context

Type of Exchange

Basic implementation of Spring IOC, including accessing configuration files, creating and managing beans, etc.

Provides extended services on basic IOC functions, in addition to providing support for many enterprise-level services

Spring's core tool package, other packages depend on this package

Spring expression language

Spring's proxy interface to the server

Integrate third-party ORM implementations, such as hibernate, ibatis, jdo and spring's jpa implementation

Provide Socket communication and push function on the web side

Simple encapsulation of test frameworks such as JUNIT

@Component component, no clear role

@Service is used in the business logic layer (service layer)

@Repository is used in the data access layer (dao layer)

@Controller is used in the presentation layer, controller declaration (C)

@Configuration declares the current class as a configuration class, which is equivalent to Spring configuration in xml form (on the class)

The @Bean annotation is on the method, declaring that the return value of the current method is a bean, replacing the method in xml (used on the method)

@ComponentScan is used to scan Component, which is equivalent to (on class) in xml

@WishlyConfiguration is the combined annotation of @Configuration and @ComponentScan, which can replace these two annotations.

@Aspect declares an aspect (on the class)

@After executes after the method is executed (on the method)

@Before is executed before the method is executed (on the method)

@Around is executed before and after the method is executed (on the method)

@PointCut declares pointcuts

@EnableAspectJAutoProxy

@EnableAsync turns on support for asynchronous methods

@EnableScheduling turns on support for scheduled tasks

@EnableWebMvc turns on Web MVC configuration support

@EnableConfigurationProperties enables support for @ConfigurationProperties annotation configuration beans

@EnableJpaRepositories turns on support for SpringData JPA Repository

@EnableTransactionManagement turns on support for annotated transactions

@EnableTransactionManagement turns on support for annotated transactions

@EnableCaching enables annotation caching support

breakpoint

RBI

monitor

@SpringBootApplication

@RestController

@EnableAutoConfiguration

@EntityScan

webMVC

webFlux

JDBC

···

Tomcat

Jetty

Undertow

Provide solid starter dependencies to simplify build configuration

Provide operational features

No code generation, no XML configuration required

Activate autowiring-@EnableAutoConfiguration/@SpringBootApplication

Implement automatic assembly-XXXAutoConfiguration

Configure automatic assembly implementation-META-INFO/spring.factories

service gateway

Service configuration

Service registration/service configuration

event driven

Function

Consumer

Supplier

Applications

Service security

Service call chain tracking and visualization with Zipkin

For Restful calls between services (REST client)

Service governance

spring-cloud-starter-task

@EnableTask

spring-cloud-starter-bus-amqp

spring-cloud-starter-bus-kafka

Service fault tolerance

de.codecentric.spring-boot-admin-starter-server

@EnableAdminServer

DashBoard

Application

Server

Deployer

spring-cloud-starter-contract-verifier

spring-cloud-starter-contract-stub-runner

XML configuration method

Annotation annotation method

properties

setting

typeAliases

typeHandlers

objectFactory

plugins

environments

databaseProvider

mapper

pageHelper

Matching of jdbcType and database field type

Splice sql by method name

@Query

Programmatic

JpaRepository<T, ID>

PagingAndSortingRepository<T, ID>

CrudRepository<T, ID>

flush

Netty not only supports HTTP protocol, but also supports multiple application layer protocols such as SSH, TLS/SSL, etc.

Tomcat needs to follow the Servlet specification. Before Servlet 3.0, it used the synchronous blocking model.

Netty has a different focus than Tomcat. It does not need to be constrained by the Servlet specification and maximizes the NIO features.

TTL

LRU

Worker

Shuffle

Fields

All

Global

None

Direct

Local or shuffle

@DisallowConcurrentExecution

JobDetail

Trigger

Schedule

Dynamically include the content of another page through iframe, javascript, ajax, etc.

The page can still be turned into a static html page, and where dynamic is required, it can be loaded dynamically through iframe, javascript or ajax.

Relatively simple and does not require changes and configurations on the server side

Not conducive to search engine optimization (iframe method), javascript compatibility issues, and client-side caching issues may cause untimely updates

Load different modules through comment line SSI commands and build them into html to update the content of the entire website.

The corresponding files of each module are called through SSI and finally assembled into an html page, which requires server module support.

It is not limited by specific languages ​​and is relatively universal. It only needs the support of a web server or application server, such as Ngnix, Apache, IIS, etc.

SSI can only be loaded on the current server and cannot directly include files on other servers (that is, it cannot be included across domains)

Use simple markup language to describe content fragments in web pages that can and cannot be accelerated

Can be used to cache entire pages or page fragments, mostly executed on cache servers or proxy servers.

Currently, there are relatively few softwares that support ESI, and official updates are a bit slow, so it is not widely used.

Detect key specifications and intercept malicious attacks

If the object queried from the database is empty, it is also put into the cache. Set a shorter cache expiration time, such as 60 seconds.

Allows cache to never expire

The application first fetches the data from the cache. If it does not get it, it fetches the data from the database. After success, it puts it in the cache.

During the writing process, the data is stored in the database. After success, the cache is invalidated.

read

renew

The application only accesses the cache, not the database

Split a whole piece of data into several parts for caching, and distinguish between frequently updated and infrequently updated parts.

SMB

NFS

AFS

FibreChannel

iSCSI

ATA over Etherent (AoE)

HyperSCSI

GET

PUT

POST

DELETE

Object storage uses the hash value of the object as a globally unique identifier

Use a high-digit hash function to calculate hash values ​​to ensure that data with different content has different hash values.

ElasticSearch

Because the setnx expire operation is not atomic

public boolean tryLock_with_lua(String key, String UniqueId, int seconds) { String lua_scripts = "if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then" "redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end"; List<String> keys = new ArrayList<>(); List<String> values ​​= new ArrayList<>(); keys.add(key); values.add(UniqueId); values.add(String.valueOf(seconds)); Object result = jedis.eval(lua_scripts, keys, values); //Determine whether it is successful return result.equals(1L); }

Starting from version 2.6.12, Redis adds a series of options to the SET command: SET key value[EX seconds][PX milliseconds][NX|XX] EX seconds: Set expiration time in seconds PX milliseconds: Set expiration time in milliseconds NX: Set value only if key does not exist XX: Set value only if key exists

Using the set key value [EX seconds][PX milliseconds][NX|XX] command seems fine, but in redis cluster mode, problems may still occur.

public boolean releaseLock_with_lua(String key,String value) { String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then " "return redis.call('del',KEYS[1]) else return 0 end"; return jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(value)).equals(1L); }

Get the current Unix time in milliseconds.

Try 5 instances in sequence, using the same key and

A unique value (such as UUID) acquires the lock. When requesting a lock from Redis, the client should set a network connection and response timeout, which should be less than the lock expiration time. For example, if your lock's automatic expiration time is 10 seconds, the timeout should be between 5-50 milliseconds. This can avoid the situation where the server-side Redis has hung up and the client is still waiting for the response result. If the server does not respond within the specified time, the client should try to obtain a lock from another Redis instance as soon as possible.

The client uses the current time minus the time when it started to acquire the lock (the time recorded in step 1) to get the time used to acquire the lock.

The lock is considered successful if and only if the lock is obtained from the majority (N/2 1, here is 3 nodes) of Redis nodes and the usage time is less than the lock expiration time.

If the lock is acquired, the real valid time of the key is equal to the valid time minus the time used to acquire the lock (the result calculated in step 3).

If for some reason, the lock acquisition fails (the lock is not acquired on at least N/2 1 Redis instances or the lock acquisition time has exceeded the effective time), the client should

Unlock all Redis instances (even if some Redis instances are not locked successfully at all, this prevents some nodes from acquiring the lock but the client does not receive a response and the lock cannot be reacquired for a period of time).

Introduce pom

Get lock

Unique ID

Unlock

1. NAT technology requires the request message and the response message to be rewritten through LB. Therefore, when the website visits are relatively large, there is a relatively large bottleneck in the LB load balancing scheduler. Generally, a maximum of 10-20 units are required. node

2. You only need to configure a public network 1P address on the LB.

3. The gateway address of each internal realserver server must be the intranet address of the scheduler LB.

4. NAT mode supports IP address and port translation. That is, the port requested by the user and the port of the real server may be inconsistent.

The physical servers in the cluster can use any operating system that supports TCP/IP, only the load balancer requires a valid IP address

Scalability is limited. When server nodes (ordinary PC servers) grow too much, the load balancer will become the bottleneck of the entire system, because all request packets and response packets flow through the load balancer.

When there are too many server nodes, a large number of data packets will converge on the load balancer, and the speed will slow down!

1. Forwarding is implemented by modifying the destination MAC address of the data packet on the scheduler LB. Note that the source address is still the CIP and the destination address is still the VIP address.

2. The requested message passes through the scheduler, while the RS response processed message does not need to pass through the scheduler LB, so the usage efficiency is very high when the amount of concurrent access is large (compared with NAT mode)

3. Because DR mode implements forwarding through the MAC address rewriting mechanism, all RS nodes and scheduler LB can only be in one LAN.

4. The RS host needs to bind the VIP address to the LO interface (mask 32 bits), and configure ARP suppression.

5. The default gateway of the RS node does not need to be configured as an LB, but directly configured as the gateway of the upper-level route, which allows the RS to directly go out of the network.

Like TUN (tunnel mode), the load balancer only distributes requests, and response packets are returned to the client through a separate routing method. Compared with VS-TUN, VS-DR does not require a tunnel structure, so most operating systems can be used as physical servers.

The DR mode is very efficient, but the configuration is a little more complicated, so companies that do not have particularly large visits can use haproxy/nginx instead. If you have 1000-2000W PV per day or less than 10,000 concurrent requests, you can consider using haproxy/nginx.

All RS nodes and scheduler LB can only be in one LAN

1.TUNNEL mode must bind VIP IP addresses on all realserver machines

2. TUNNEL mode vip------>realserver's packet communication is through TUNNEL mode, and it can communicate whether it is the internal network or the external network, so there is no need for /vs vip and realserver to be in the same network segment.

3. In TUNNEL mode, realserver will send the packet directly to the client and not to Ivs.

4. TUNNEL mode uses tunnel mode, so it is difficult to operate and maintain, so it is generally not used.

The load balancer is only responsible for distributing request packets to backend node servers, while RS sends response packets directly to users.

Reducing the large amount of data flow in the load balancer, the load balancer is no longer the bottleneck of the system and can handle a huge amount of requests. In this way, one load balancer can distribute to many RSs. And it can be distributed in different regions by running on the public Internet.

The RS node in tunnel mode requires a legal IP. This method requires all servers to support the "IP Tunneling" (IPEncapsulation) protocol. The server may be limited to some Linux systems.

1.FULL NAT mode does not require LBIP and realserver IP to be in the same network segment;

2. Because the source ip needs to be updated, the performance of full nat is normally 10% lower than that of nat mode.

Half of the writes from the database are successful, which means the operation is successful.

Determine whose log is the latest (determined based on the log index in the voting request of other nodes and your own log index)

Request other nodes to vote for themselves (generally issued by Candidate)

Used for log replication, indicating the entries added to the log, used for heartbeat when the number of entries is 0

Sent by Leader

object relations

Structure diagram

Memory classification

Memory reclamation strategy

Pipeline

Redis cluster solution

Master-slave synchronization

asynchronous queue

Redis persistence

Compare with memcached

Applicable scene

The difference between Redis and Memcache

Redis Java client

common problem

Structure diagram

It is a master-slave data synchronization solution for MySQL and most mainstream databases.

Time complexity O(1)

High TPS

Does not support scheduled messages

High concurrency (caused by Erlang language implementation characteristics)

High reliability and high availability

Heavyweight

RabbitMQ’s publish-subscribe model

Exchange

temporary queue

Binding

nameserver

broker

producer

consumer

High data reliability

Real-time message delivery

High TPS

Strict message order

Support scheduled messages

Supports backtracking messages by time

Billions of messages piled up

The consumption process must be idempotent (remove duplication)