Please enable JavaScript.

Coggle requires JavaScript to display documents.

Interview-map, Spring, Multi Thread, database, Architecture, HEAP/STACK…

- - - - manage and scaleThread
- - - - dependency injection containers
        
        IOC container
        ( IOC container implementation)
        
        ai đó biết class userDao có constructor dependency
        
        biết cách construct nó
        
        lúc này bạn có thể sử dụng userDao với dataSource
        => Ai đó là dependency injection container
        
        Nhờ vào DI + IOC =>
        IOC container :
        
        BeanFactory
        
        ApplicationContext
        
        ApplicationContext Implementation
        
        AnnotationConfigApplicationContext
        
        AnnotationConfigWebApplicationContext
        
        XmlWebApplicationContext
        
        FileSystemXMLApplicationContext
        
        ClassPathXmlApplicationContext
        
        load bean
        
        manage bean
        
        wire bean
        
        Mục đích quản lý bean
      - Ước gì có ai đó biết mình cần gì
        
        userDao didnt have to worry about finding dependencies at all (dataSource)
      - NOTE: đây chỉ là principle
        PROGRAMING PRINCIPLE
        design principle to achieve loose coupling
        
        thay vì class A depend on class B, class C
        
        class B, class C được inject vào class A
        
        framework control flow program
        
        construct bean
        
        easy switch different implementation
  - - - new AnnotationConfigApplicationContext()
        
        new ClassPathXmlApplicationContext()
    - - specify packages that we want to scan bean
        
        Spring will scan its package by default
      - how does Spring know if something is a Spring bean?
        
        marker Component
      - Component is a bean
        
        if a component has Autowired
        => this component need inject a bean
        
        Component (class level) Spring 2.5
        
        Bean (method level) Spring 3.0
    - - scope
        
        question
        
        singleton
        
        all your DAOs share the same resource
        
        single bean for each Spring IOC container
        
        prototype
        
        all your DAOs has their own resource
        
        every time you need a reference to your bean, Spring will create a new one
        
        per httpRequest?
        
        per httpSession?
        
        per WebSocket?
      - life cycle
        
        customize bean
        
        bean init
        
        dependencies inject
        
        setProperties
        
        init() method
        
        postContruct
        
        ready to use
        
        1 more item...
        
        || InitializingBean.propertiesSet()
    - - WHY
        
        HOW
        
        create a proxy to wrap a bean
        
        Ex: Transactional
        
        open database connection
        
        close transaction (committed/rerolled...)
        
        config your bean some additional features
    - - create bean
      - setting properties
      - wiring dependencies
      - manage bean lifecycle
- - - - Value
- - - - using by
        
        get/set method
      - declare
        
        ThreadLocal<Integrer> a = new ThreadLocal<>()
        
        = ThreadLocal.withInitial(()->1)
    - - becareful using threadLocal with threadPool
        
        after finish task, thread may be reuse threadlocal in previous process
        => must be remove previous task data
        
        solved:
        class extend ThreadPoolExecutor
        
        => customHook
        
        beforeExecute()
        
        afterExecute()
  - - - instance method
      - static method
  - - - sử dụng khi chỉ có 1 thread ghi, các thread còn lại đọc
        
        nếu multiple thread ghi -> synchronize
  - - - lock object -> mỗi thời điểm chỉ có 1 thread access
        -> actomic fix it
- - - - khi new một thread -> tốn resource creating
        
        khi một thread hoạt động xong, nó sẽ không chết mà ở vào trạng thái chờ để hoạt động tiếp
        
        thread pool keep no task thread for waiting new task
        
        if all thread is busy, new task request will be keep in blockingQueue and waiting for any thread completed task to pick it
  - - - instead of creating new thread -> thread pool keep a number of idle thread and they are all available
      - after completed a task, thread wont be died, it will be keep in thread pool
      - task -> blocking queue
  - - - cached threadpool
      - fixed thread pool
        
        corePoolSize-maxedPoolSize-capacitySize
      - single thread pool
      - fork/join pool
  - - - ThreadPoolExecutor
        
        advance class
        
        config corepool...
- - - - single sequential flow of control execution in a program
    - - two or more thread is executed in the same time
  - - - put all input thread into queue and sequential exectuting
      - synchronized method
      - synchronized object
    - - to avoid conflict data
        
        secure data consistence
    - - => đồng bộ hóa là thứ tự hóa
      - Synchronization is the ordering of threads accessing the same object so that the object does not have data conflicts
  - - - multi thread waiting for resource, acquired by another thread
    - - 2 or more thread access and update same resource in the same time,
    - - tìm ra data chung -> khóa chúng lại (object locking)
- - - - void run()
        
        Dùng Runnable thay vì Thread khi mình muốn chia sẻ biến với nhau
    - - return Future<T> submit(Callable<T>) throw Exception
        
        method
        
        isDone()
        
        cancel()
        
        isCancel()
        
        get()
        
        place holder of the result, When the operation completed, Future will contains the result
    - - CompletableFuture<T>
        
        class CompletableFuture<T> implement Future<T>
        
        support
        
        chạy bất đồng bộ
        
        hỗ trợ viết logic
        
        combine chain
        
        call back
        
        thenApply()
        
        thenAccept()
        
        thenRun()
        
        exception
        
        functional programing approach
        
        Future's implementation
  - - - t1.join vào luồng hiện tại
        
        => luồng hiện tại phải đợi t1 chạy xong mới được chạy tiếp
  - - - still alive but not run
    - - suspend - sleep - wait
- - - - multi tasking
        
        multithreading
        
        prefer cause:
        
        light weight
        
        shared memory -> faster content switching
        
        multiprocessing
  - - - 1 Tiến trình có nhiều luồng (game đế chế)
        
        tải map
        
        nhân vật chuyển động
        
        nghe nhạc
        
        chat
- - - - treat entity class as relational tables
    - - LAZY
        
        => toMany
        OneToMany, ManyToMany
        
        fetch on request
      - EAGER
        
        => ToOne
        ManyToOne, OneToOne
        
        Fetch all associated data
  - - - in persistence context - ready to save
    - - from inside context -> move outside context
        has Id - not manage by context
      - muốn save lại ->
        
        attach
    - - outside persistence context - have not Id
  - - - make sure everything is ready to use
    - - provide api to work with domain entity
    - - 1 request -> 1 transaction to work
      - if have multiple transaction -> do not share level cache
        
        solved by 2nd level cache
  - - - load class thuộc về student -> gọi n+1 query
- - - - nhược:
        
        đợi quá lâu
        
        có thể xảy ra deadlock
      - locking entities on database level
        
        hold the lock, no transaction can update on locked data
    - - while using it, each transaction read data hold in version
        
        when update, it check data in version again
        
        If value changed -> OptimisticLockExxception is thrown
      - có 2 transaction đồng thời đến row
        
        kiểm tra version
        
        trans 1 updated -> edit version
        
        trans2 updated -> thấy khác version -> quăng lỗi
  - - - read-only lock
        
        chỉ đọc không ghi
    - - write lock
        
        tại 1 thời điểm, chỉ có 1 transaction được ghi
        
        không thể share lock trên exclusive lock
    - - mixing giữa 2 cái trên
        
        khi update -> exclusive lock
        
        read thì share lock
  - - - lock prevent another transaction change data
    - - when a row is locking, another transaction cannot work with this row
        
        have to wait till that row available
  - - - dirty read
    - - default read
    - - same as read committed
        
        do not update when a transaction read this row
- - - - each entity loaded by only once in the persistence context
      - session closed -> first layer cached -> terminated as well
    - - multiple session shared data in 2nd level cache space
      - get data:
        
        check from 1st layer cache
        
        check from 2nd layer cache (ware house)
        
        fetch from db
- - - - saved data must not damaged data integrate
    - - database transaction must complete task independently from other
        
        multiple transaction - concurrent transaction
        -> dirty read (read_uncommitted)
    - - the committed wont be lost event with the system or power failure
- - - - small team work sperate
      - easy deploy
        
        deploy faster
      - easy to choose/switch programming language
        
        adapt new techlogogies
      - a service fail -> not stop application
  - - - same approach with loosely coupled services
      - together things change for same reason
        
        different things change for different reason
- - - - đánh độ ưu tiên của object khi remove
    - - free memory bằng cách remove những object mà method không reference đến nữa
        
        process
        
        garbage collection goes through the heap
        
        marks object that are in use
        
        goes back and reclaims the memory of any objects that was not mark
        
        3 vùng:
        
        1 - Young generation (Eden-S0-S1)
        
        3 vùng Eden, S0, S1
        
        khi Object mới tạo -> nằm trong Eden
        
        Sau nhiều chu trình quét mà Object vẫn referenced -> đẩy vào S0, S1
        
        2 - old generation
        
        sau 1 số chu trình quét -> object còn sống sẽ được chuyển từ young -> old generation
        
        3 - Permanent generation
        
        không chứa object, chứa metadata mô tả class, method
        
        process
        
        1 - marking
        
        đi 1 vòng
        
        đánh dấu những Object còn và k còn referenced
        
        2 - normal deleting
        
        xóa những Object không còn refferenced
        
        3 - deletion with compacting
        
        shift object lại gần nhau để tăng hiệu suất sử dụng bộ nhớ
  - - - không bao giờ bị garbage collected
- - - - queue (1- 1)
    - - public - subscribe (1-n)
- - - - producer push msg into Kafka topic
        
        consumer pull msg from Kafka topic
  - - - provide
        
        scalability
        
        redundancy
      - Called Brokers
        
        Each Brokers holds a subset of record
  - - - file
        
        topic
        
        partition
        
        offset
        
        message
    - - logfile
        
        partition
        
        replicas
        
        segments
        
        replicas
        
        segments
- - - - zooKeeper decide which replication become leader
  - - - producer send msg -> broker (round robin)
        
        broker -> partition
    - - ACK - acknowledgement
    - - message key (hash key by default)
  - - - read entire data from one or multiple partition to ensure msg ordering
- - - - Context switch: là quá trình mà cpu…
        
        stop thread 1
        
        schedule thread 1 out
        
        schedule thread 2 in
        
        start thread 2...
        
        context switch is not cheap
        
        when switch to diff thread (store data for on thread, restore data for another thread)
        
        => Nếu có quá nhiều thread => quá trình quản lý thread còn tốn nhiều chi phí hơn
        
        Thread tiêu thụ ít resource hon process
        
        context switching giữa các thread trong cùng process thì tiết kiệm chi phí hơn CS giữa các thread khác process
  - - - static priority + bonus
  - - - task share a lot of dât
        
        thread are much fasster to create and destroy
        
        switching between thread of same process is faster
    - - security - stability are of higher importance (process isolate - completely isolated -> an toàn hơn mặc dù chi phí đắt hơn)
- - - - ID
        
        File
        
        Code
        
        Heap
        
        Main thread (Stack - Instruction pointer)
        
        Multi thread ->
        
        Mỗi thread đều có Stack và Instruction pointer riêng
        
        Threads share: File, Heap, Code
        
        Stack: Region in memory, where local var ar stored and passed into function
        
        Multi thread có stack và instruction pointer riêng
        Vì mỗi lúc mỗi thread chạy mỗi instruction khác và mỗi function khác
        
        Instruction Pointer: Address of next instruction to execute
- - - - template of an object
        
        contains
        
        constructor
        
        method
        
        field
        
        initialize
        
        static
        
        instance
  - - - data hiding
        
        display information needed
        
        hide unnecessary information
        
        help to reduce programing complexity and effort
        
        hide unnecessary detail from users
        
        keep users from viewing complex implementation and provide necessary information
        
        hiding data from design level
    - - class
        
        abstract method
        
        method definition but not implementation
        (without body)
        
        used when two or more subclass do the same task in difference way (difference implementation)
        
        abstract class
        
        have one or more abstract method
      - interface
        
        achieve security
        
        hide certain details, only show important details
        
        Java doesnot support inheritance multiple class -> interface solve this
  - - - achieve by
        
        class level
        
        single interface can have difference implementation
        
        single class can have difference instance value
        
        method level
        
        overloadding
        
        overriding
        
        overloading - compile time
        
        overriding - run time
  - - - build a class from existing class, to reuse parent's field and method
- - - - lambda expression
    - - easy form of lambda expression
- - - - device comes up with multiple core
        
        Parallel Streams
      - dev need to learn programing pattern to maximize the use of multiple core
      - apply parallel
    - - micro service architecture
      - blocking IO are common in MS Architecture
        => this also impact latency of the application
        
        CompletableFuture
        
        Thread
        
        Funcional programing
      - apply Async programing concept
  - - - có thể implement trên 1 hoặc nhiều core
      - correctly and efficiently controlling access to shared resource
    - - chỉ có thể implement ở multiple core machine
      - using more resources to access the result fasster
- - - - large community
    - - write one, run any where
  - - - allocate memory
        
        cấp phát bộ nhớ
      - parse and execute
        
        read, run command
  - - - class.java -> JVM -> class.class (byte code)
- - - - reads the ".class" file
        
        generate corresponding binary data
    - - verification, preparation
        
        checking whether this file valid to compile or not
        
        allocates memory for class variable, and default values
  - - - class level information
        
        class name, parent class name, method, variable...
    - - objects
    - - every thread, JVM create one run-time stack corresponding
    - - address of current execution instruction of thread
    - - store native method
  - - - garbage collector in here
- - - - hướng đến:
        
        tính kết hợp (combine)
        
        tối ưu tính tái sử dụng (reusebility)
        
        thay vì thực hiện tuần tự theo từng bước với các biến trạng thái
        
        biến trong FP phải là immutable (final)
        
        FP focus to execute the flow through combine function
        
        nhờ pure function -> dễ sử dụng multi threading
        
        purefunction
        
        immutable object
        
        no side effect
        
        => thread safe
      - key concept
        
        first class object
        
        interface implementation instance
        
        lambda expression
        
        pure function
        
        return value depend on input
        
        no side effect
        
        do not change state of out side var
        
        higher order function
        
        function take function as parameter
        
        function return a function as a parametter
      - rule
        
        only local var (temp var)
        
        no state
        
        immutable variable
        
        no side effect
    - - chia 1 hàm lớn thành nhiều hàm thủ tục để dễ lập trình và kiểm tra
  - - - single abstract method interface
        
        Hello greeting(String name)
    - - create implementation for functional interface
        
        helpful for developing functional programming
        
        Hello venky = name -> "xin chao, toi la "+ name;
        sout(venky.greeting("vuong"))
        
        argument list
        
        arrow operator (->)
        
        body
      - anonymous method
        
        simplying code when working with Stream collection
      - trước Java 8: create anonymous inner class
        
        java 8: lamda
    - - Predicate<T>
        
        filter
      - map
        
        Function<T, R>
        
        take value return value
        
        UnaryOperator<T>
        
        Take 1 value, return same type value
        
        BinaryOperator<T>
        
        take 2 value, return same type value
      - Supplier<>
        
        take nothing, return value
      - Consumer<>
        
        take value, return nothing (void)
  - - - provide functional approach with collections data
    - - non-terminal operations
        
        transform or filter element
        
        return Stream<T>
        
        combine to be a chain
        
        filter
        
        map
        
        flatmap
        
        take a Java Lambda expression as parameter
        
        pipeline
        
        bulder có hàm accept nhận Consumer<T>
      - terminal operations
        
        return value
        
        boolean
        
        anyOf()
        
        allMatch()
        
        noneMatch()
        
        collect
        
        find
        
        findAny
        
        findFirst
        
        forEach(Consumer<T>)
      - source
    - - stream
        
        support functional programming
        
        support to improve performance
        by using multi thread (parallel stream)
    - - ensure code is thread-safe
        
        thread-safe: multi thread use same resource, but do not share state
        
        achieve thread-safe
        (pure function)
        
        immutable implementation class
        
        achieve by inject data in constructor
        
        final field
        
        private final String msg
        public MesageService(String msg){}
        
        thread-local fields
        
        private final field
        
        class has own state, not share each other
        
        ThreadLocal<I>
        
        same ass classField, except we can access it via getter setter
      - note
        
        do not parallel if findFirst()
    - - lazy execution
        
        invoked only if terminal operation is declared
      - sequential operation
        
        thực hiện tuần tự
- - - - nếu block code ở try và finally đều throw exception, thì exception ở finally sẽ đàn áp exception ở try
    - - nếu cả try và finally đều throw exception -> try exception sẽ được throw ra trước
- - - - two instance equal => same hashCode
      - always override hashCode if override equal()
  - - - return integer representing the current instance of class
- - - - isolation
        
        READ
        
        READ_UNCOMMITTED
        
        READ_COMMITTED
        
        REPEATABLE_READ
        
        SERIALIZABLE_READ
        
        data isolation level
    - - propagation
        
        REQUIRED
        
        REQUIRED_NEW
        
        SUPPORT
        
        MANDATORY
        
        ....
        
        logical transactions
        
        Transactional(propagation = Propagation.REQUIRES_NEW)
        
        spring open two physical connection to database
        
        tell Spring, this method need its own transaction
  - - - Spring achieve it by using AOP
        
        proxy access transaction manager and ask it to open / close connection
        
        create dynamic proxy
  - - - consistency
        
        conform to existing constraints
        
        data is in a consistent state when a transactions start till its end
        
        saved data must not damaged data integrate
      - isolation
        
        Each transaction is dependent of other transaction
        
        not affect other transaction
        
        database transaction must complete task independently from other
        
        multiple transaction - concurrent transaction
        -> dirty read (read_uncommitted)
      - Atomicity - all or nothing
        
        be completed or no effect
        
        If any part of transaction fails, the entire will operation rolls back
        
        all the changes are performed or none them are
      - durability
        
        All transaction results are permanently preserved
        
        the committed wont be lost event with the system or power failure
- - - - PreAuthorize
        
        PostAuthorize
        
        Secured
    - - config
        
        http.authorizeRequest().antMatchers().hasRole()
      - implements GrantedAuthority
        
        UserDetail getRoles()
      - roles
        
        ROLE_ prefix
        
        ROLE_ADMIN
        
        ROLE_USER
    - - access userpassword
        
        not having access password
        (3rd party)
        
        Extract username and password
        
        AuthenticationProvider
        
        return UserNamePasswordAuthenticationToken
        
        authenticate() by AuthenticationProvider
        
        having access password
        
        userDetailService
        
        passwordEncoder
      - config
        
        EnableWebSecurity
        
        extend WebSecurityConfigurerAdapter
        
        configure(HttpSecurity)
        
        which URL
        
        protected
        
        allowed
  - - - authenticated
      - chain.doFilter()
        
        request -> DispatcherServlet -> Controllers
      - authorized
      - UsernameAndPasswordToken
        
        from Token, Header, FormField, Cookie...
    - - servlet filter
        
        request -> a couple of of filter chain -> Dispatcher Servlet -> Controllers
      - authorization
        
        user's permission
      - authentication
        
        verify user
- - - - OneToMany
        JoinColumn
        
        JoinColumn sẽ khiến thêm cột ở bảng còn lại, không thêm extra table
        
        By default, OneToMany sẽ generate extra table
    - - ManyToOne
        và
        OneToMany(MappedBy=)
        
        mappedBy sẽ nói hibernate rằng, tôi từ bỏ việc quản lý annotation ở bảng hiện tại
        => Bảng OneToMany không thêm extra table
        
        Nếu có cả OneToMany
        và
        ManyToOne
        
        => Hibernate sẽ
        
        generate extra table
        
        thêm cột
- - - - OneToMany
        JoinColumn(name="person_id")
        Set<Address> addresses;
    - - OneToMany(mappedBy="person")
        Set<Address> addresses
- - - - PagingAndSorting<T,ID>
- - - - CPU intensive task
        
        threadpool. size = number of core
      - IO task
        
        threadpool size > number of core
    - - no need to manually create, start, join the threads
      - archieving concurrency in application
- - - - lost update
    - - pessimistic locking
        
        lock and wait to unlock
      - optimistic loking
        
        using version