First of all, a monthly salary of 30,000 yuan is too common in BAT, usually for senior engineer and senior engineer positions. It is around p6 in Ali, t5 in Baidu, t2-3 in Tencent, t3-1 in JD, and p6 in Meituan. I don't know the others. This level is their main code farmer level. They work a lot of overtime and can solve most of the problems, but they still need to cultivate the overall system architecture ability and the ability to analyze bottlenecks in depth.
Secondly, the skill tree mastered mainly has three aspects: the
first is the basics.
For example, you have an in-depth understanding of collection classes, concurrent packages, class loading, IO/NIO, JVM, memory models, generics, exceptions, reflection, etc. It is best to read the source code to understand the underlying design. For example, general interviews will ask about knowledge points such as ConcurrentHashMap, CopyOnWrite, thread pool, CAS, AQS, virtual machine optimization, etc., because these are absolutely important to Internet companies. And most people can't pass this level, and they complain that these are useless, why do they have to interview. For example, when using the thread pool, because the unbounded queue is used, the inner layer soars when the remote service is abnormal. How to solve it? If you don't even know the thread pool, how can you play? To give another example, due to a misunderstanding of ThreadLocal and using it for thread-safe control, real thread-safety was not achieved. And how to troubleshoot memory leaks and how to optimize system performance. Therefore, as a JAVA programmer with 30,000 yuan, this foundation is necessary.
Second, you need to have a comprehensive knowledge of Internet technology .
Speaking from the bottom, you should at least have a deep understanding of mysql, redis, nginx, tomcat, rpc, jms, etc. You have to ask how much you need to understand, and I can give you a big deal. First of all, for MySQL, you need to know the common parameter settings, how to choose the storage engine, and you also need to understand the common index engines and know how to choose. Know how to design tables, how to optimize SQL, and how to tune according to the execution plan. For advanced users, you need to design and optimize the sub-database and sub-tables. Generally, the database of Internet companies is separated from reading and writing, and it is also split vertically and horizontally, so this is also an experienced component. Then redis is almost a necessary skill, and nginx and tomcat are almost necessary for the JAVA Internet. As for the rpc related, there are many, various network protocols, serialization technologies, SOA, etc., you need to have a deep understanding. Now the widely used rpc framework is dubbo in China. There is also a spring cloud related technology stack that is open source, and you can search by yourself. As for jms-related, at least you have to understand the principle. Under normal circumstances, those who are not specialized in developing middleware systems and support systems do not need to know too many details. Domestic companies mainly use activeMQ and kafka. All you can say to me is research, and Ali p7 is not too problematic.
The third is programming ability, programming thinking, algorithm ability, and architecture ability .
First of all, I think 2W programmers have relatively low requirements for algorithms. No matter how advanced they are, they are most red-black trees, but the basic algorithms for sorting and query must be good. Programming thinking is a must. Ask you about AOP and IOC. You are at least clear. The design pattern does not say that you have used each of them, but you can also understand a few. I don’t think it’s easy to evaluate programming ability, but it’s easy to sort a 2000W user by name and age. Finally, there is the architectural capability. This kind of system does not mean that you are required to design a system that is as powerful and concurrency as possible. At least it allows you to build a spike system. You must have a clear idea and direction.
In view of the above three points, the editor has compiled a complete set of Java study notes, enough for your monthly salary to reach about 3W! (In order not to affect everyone's reading experience, the free method of obtaining this note is at the end of the article!)
JVM articles
Thread
JVM memory area ( program counter (thread private), virtual machine stack (thread private), local method area (thread private), heap (heap-thread sharing)-runtime data area, method area/permanent generation (thread sharing))
JVM runtime memory ( new generation, old generation, permanent generation )
Garbage collection and algorithms ( how to determine garbage, mark sweep algorithm (Mark-Sweep), copy algorithm (copying), mark sorting algorithm (Mark-Compact), generational collection algorithm )
JAVA four reference types ( strong reference, soft reference, weak reference, virtual reference )
GC generational collection algorithm VS partition collection algorithm ( generational collection algorithm, partition collection algorithm )
GC garbage collector ( Serial garbage collector (single thread, copy algorithm), ParNew garbage collector (Serial+multithread), Parallel Scavenge collector (multi-threaded replication algorithm, high efficiency), Serial Old collector (single-threaded mark sorting algorithm) ), Parallel Old collector (multi-threaded mark clearing algorithm), CMS collector (multi-threaded mark clearing algorithm) )
JAVA IO/NIO ( blocking IO model, non-blocking IO model, multiplexed IO model, signal-driven IO model, asynchronous IO model, JAVA IO package, JAVA NIO, Channel, Buffer, Selector )
JVM class loading mechanism ( loading, verification, preparation, resolution, symbol reference, direct reference, initialization, class constructor <client>, class addition and trimming device, parent delegation, OSGI (dynamic model system) )
JAVA Collection
Interface inheritance and implementation
List ( ArrayList (array), Vector (array implementation, thread synchronization), LinkList (linked list) )
Set（HashSet (Hash表)、TreeSet (二叉树)、LinkHashSet (HashSet+ LinkedHashMap)）
Map ( HashMap (array + linked list + red-black tree), ConcurrentHashMap, HashTable (thread safe), TreeMap (sortable), LinkHashMap (record insertion order) )
Multithreading and high concurrency
JAVA Concurrent Knowledge Base
JAVA thread implementation/creation method ( inheriting the Thread class, implementing the Runnable interface, ExecutorService, Callable <Class>, Future thread with return value, based on the thread pool )
4 kinds of thread pools ( newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor )
Thread life cycle ( new state (NEW), ready state (RUNNABLE), running state (RUNNING), blocked state (BLOCKED), thread death (DEAD) )
4 ways to terminate the thread ( end of normal operation, use the exit flag to exit the thread, the Interrupt method to terminate the thread, the stop method to terminate the thread (thread is not safe) )
The difference between sleep and wait
The difference between start and run
JAVA background thread
JAVA lock ( optimistic lock, pessimistic lock, spin lock, Synchronized synchronization lock, ReentrantLock, Semaphore semaphore, AtomicInteger, reentrant lock (recursive lock), fair lock and unfair lock, ReadWriteLock read-write lock, shared lock and exclusive Locks, heavyweight locks (Mutex Lock), lightweight locks, biased locks, segmented locks, lock optimization )
Basic thread methods ( thread waiting (wait), thread sleep (sleep), thread yielding (yield), thread interruption (nterrupt), Join waiting for other threads to terminate, why use join0 method?, thread wake up (notiy), other methods )
Thread context switch ( process, context, register, program counter, PCB-"switching frame", context switch activity, cause of thread context switch )
Synchronization and deadlock
Principle of thread pool ( thread reuse, composition of thread pool, rejection strategy, Java thread pool work process )
JAVA blocking queue principle ( the main method of blocking queue, blocking queue in Java, ArrayBlockingQueue (fair, unfair), LinkedBlockingQueue (two independent locks to improve concurrency), PriorityBlockingQueue (compareTo sorting implementation priority), DelayQueue (cache invalidation, timing tasks ), SynchronousQueue (does not store data, can be used to transfer data), LinkedTransferQueue, LinkedBlockingDeque )
CyclicBarrier. CountDownLatch. Usage of Semaphore
The role of the volatile keyword (variable visibility, reordering prohibited)
How to share data between two threads
ThreadLocal role (thread local storage)
The difference between synchronized and ReentrantLock
ConcurrentHashMap concurrency ( reduce lock granularity, ConcurrentHashMap segment lock )
Thread scheduling used in Java ( preemptive scheduling, cooperative scheduling, implementation of JVM thread scheduling (preemptive scheduling), thread giving up cpu )
Process scheduling algorithm ( priority scheduling algorithm, high priority priority scheduling algorithm, round-robin scheduling algorithm based on time slice )
What is CAS (Compare and Exchange-Optimistic Lock Mechanism-Lock Spin)
What is AQS (Abstract Queue Synchronizer)
Spring Principles
Spring features ( lightweight, inversion of control, aspect-oriented, container )
Spring core components
Spring common modules
Spring main package
Spring common annotations
Spring third-party integration
Spring IOC principle ( concept, Spring container high-level view, IOC container implementation, Spring Bean scope, Spring Bean life cycle, Spring dependency injection four ways, 5 different ways of automatic assembly )
Spring APO principle ( concept, AOP core concept, AOP two proxy modes, realization principle )
Spring MVC principle
Principles of Spring Boot ( create independent Spring applications, embedded Tomcat, no need to deploy WAR files, simplify Maven configuration, automatically configure Spring, provide production-ready features, such as indicators, health checks and external configuration, absolutely no code generation and XML No configuration required )
Principles of JPA ( transactions, local transactions, distributed transactions, two-phase commit )
Mybatis cache (first level, second level)
Tomcat architecture
Database articles
Storage engine ( concept, InnoDB (B+ tree), TokuDB (Fratal Tree node with data), MyIASM, Memory )
index
Database three paradigms . First paradigm (1st NF-columns are not subdivided), second paradigm (2nd NF-each table only describes one thing, third paradigm (3rd NF-there is no transitive dependency on non-primary key columns) )
The database is a transaction ( Atomicity, Consistency, Isolation, Durability )
Stored procedures (set of SQL statements for specific functions)
Trigger (a program that can be executed automatically)
Database concurrency strategy ( optimistic lock, pessimistic lock, timestamp )
Database locks ( row-level locks, table-level locks, page-level locks )
Distributed lock based on Redis
Classification table ( vertical division (according to functional modules), horizontal division (according to the rules of storage) )
Two-phase submission agreement ( preparation phase, submission phase, shortcomings )
Three-phase commit protocol ( CanCommit phase, PreCommit phase, doCommit phase )
Flexible transaction
CAP ( consistency, availability, partition tolerance )
The content of this knowledge point is really too much, and an article can't be written at all. Let me show you the content of this note.
Each part of this note covers a lot of content, from basic to advanced. At the same time, this note has nearly 1000 pages, all of which are the summary of the most essential parts of the note author himself. Today is a free gift and needs to be received for free. My friend, please help me with one click and three links to this article + follow me, scan the code to get it!
