JAVA基础

最新推荐文章于 2024-07-20 23:55:03 发布

chenyipengAI

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量117

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/qq_35367268/article/details/118885671

版权

Java基础知识汇总

1.java的jvm内存

JVM虚拟机器结构
虚拟机的结详细结构
虚拟机栈详细结构
虚拟机堆的详细结构
虚拟机堆栈关系结构
虚拟机中堆对象的详细结构
虚拟机中的方法区所存储的内容

     1类信息,包括类名(包名+类名),直接父类的完整有效名,修饰符,直接接口的列表
     2方法名称,参数列表和类型,方法的返回类型,方法的名称,,操作数栈,
     3局部变量表以及大小异常表
     4.运行时常量池

1.1java的类成员加载的过程

1.1.1类加载过程中成员属性的顺序

----1)父类的静态代码块
----2)父类的静态属性(静态属性和静态代码快按照写的先后顺序加载)
----3)子类的静态代码块
----4)子类的静态属性
----5)父类的成员属性
----6)父类的普通代码块(成员属性和普通的代码块按照先后顺序加载)
----7)父类的构造方法
----8)子类的成员属性
----9)子类的普通的代码块
---10)子类的构造方法

1.1.2哪些行为触发类的加载行为

--1)使用new关键字实例化对象
--2)读取一个类的静态字段
--3)设置一个类的静态字段
--4)调用一个类的静态方法
--5)被final修饰静态字段在操作使用时，不会使类进行初始化，因在编译期已经将此常量放在常量池。
--6）子类调用或者设置父类的静态字段或者调用父类的静态方法时仅仅初始化父类，而不初始化子类。同样读取final修饰的常量不会进行类的初始化。

1.1.3类加载器有哪些了

--1)启动类加载器BootstrapClassLoader:
是嵌在JVM内核中的加载器，该加载器是用C++语言写的，主要负载加载JAVA_HOME/lib下的类库，启动类加载器无法被应用程序直接使用。
---2)扩展类加载器Extension ClassLoader：
该加载器器是用JAVA编写，且它的父类加载器是Bootstrap，主要加载JAVA_HOME/lib/ext目录中的类库。开发者可以这几使用扩展类加载器。我们知道java中系统属性java.ext.dirs指定的目录由ExtClassLoader加载器加载，如果程序中没有指定该系统属性（-Djava.ext.dirs=sss/lib）那么该加载器默认加载$JAVA_HOME/lib/ext目录下的所有jar文件，通过程序来看下系统变量java.ext.dirs所指定的路径：
---3)系统类加载器App ClassLoader：
系统类加载器，也称为应用程序类加载器，负责加载应用程序classpath目录下的所有jar和class文件。它的父加载器为Ext ClassLoader。

1.1.java内存结构

1.2.java内存模型

2.java集合框架以及数据结构

3.java网络编程以及HTTP协议

3.1.java常见的堵塞式BIO

 public static void main(String[] args) throws IOException, InterruptedException {
        //服务端的socket程序
        ServerSocket  socket=new ServerSocket(9999);
        System.out.println("server  is  start");
        Socket accept;
        /**
         * 1.该方式存在两处堵塞的情况，第一个是socket.accept()
         * 第二种情况是in.read()这两种情况都会出现堵塞的
         * 2.当采用socket.accept()的方式的时候该方法会堵塞当前的线程直到accept建立一个连接
         * 3.当采用in.read()会一直尝试读取数据，也会堵塞当前线程
         */
        while(true) {
            accept = socket.accept();
            InputStream in = accept.getInputStream();
            OutputStream out = accept.getOutputStream();
            byte arr[]=new byte[1024];
            int len=-1;
            while((len=in.read(arr))!=-1){
                System.out.println(new String(arr));
                break;
            }
            out.write("I  is  server".getBytes());
        }
    }

以下是非堵塞式io的事例

 public void serve(int port) throws IOException {

        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        ServerSocket ss = serverChannel.socket();
        InetSocketAddress address = new InetSocketAddress(port);
        ss.bind(address);                                            //1
        Selector selector = Selector.open();                        //2
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);    //3
        final ByteBuffer msg = ByteBuffer.wrap("Hi!\r\n".getBytes());
        for (;;) {
            try {
                selector.select();                                    //4
            } catch (IOException ex) {
                ex.printStackTrace();
                // handle exception
                break;
            }
            Set<SelectionKey> readyKeys = selector.selectedKeys();    //5
            Iterator<SelectionKey> iterator = readyKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                try {
                    if (key.isAcceptable()) {                //6
                        ServerSocketChannel server =
                                (ServerSocketChannel)key.channel();
                        SocketChannel client = server.accept();
                        client.configureBlocking(false);
                        client.register(selector, SelectionKey.OP_WRITE |
                                SelectionKey.OP_READ, msg.duplicate());    //7
                        System.out.println(
                                "Accepted connection from " + client);
                    }
                    if (key.isWritable()) {                //8
                        SocketChannel client =
                                (SocketChannel)key.channel();
                        ByteBuffer buffer =
                                (ByteBuffer)key.attachment();
                        while (buffer.hasRemaining()) {
                            if (client.write(buffer) == 0) {        //9
                                break;
                            }
                        }
                        client.close();                    //10
                    }
                } catch (IOException ex) {
                    key.cancel();
                    try {
                        key.channel().close();
                    } catch (IOException cex) {
                        // 在关闭时忽略
                    }
                }
            }
        }
    }

1.NIO首先采用的是建立ServerSocketChannel 的通道，建立通道是方便对ServerSocket进行包装，这样才会产生事件，其实这个用框架来打比方，比如springmvc对servlet进行包装一样，不进行包装就没法实现其想要的功能，但是SererSocket才是原生态的。
2.然后可以设置一下该对象的一些属性，比如是否为堵塞等等信息，然后通过ServerSocketChannel 建立一个ServerSocket的服雾。
3.Selector打开一个选择器，该选择器就是用来监听通道的事件的
当然还要把打开的通道和事件

5.java的JUC并发包

5.1.并发包中常见的类

//下面是java.util.concurrent包下面的五大并发长见安全包

    //集合安全类 java.util.concurrent
    private ConcurrentHashMap<String,String>  hashMap=new ConcurrentHashMap<>();
    private CopyOnWriteArrayList<String>  list=new CopyOnWriteArrayList<>();
    private CopyOnWriteArraySet<String>  set=new CopyOnWriteArraySet<>();

    //原子类 java.util.concurrent.atomic
    private AtomicInteger atomicInteger=new AtomicInteger();
    private AtomicLong atomicLong=new AtomicLong();
    private AtomicBoolean atomicBoolean=new AtomicBoolean();

    /**
     * 1.锁相关的类
     * 2.线程间的通讯类
     */
    //排他锁
    Lock  lock= new ReentrantLock();
    //读锁
    Lock readLock = new ReentrantReadWriteLock().readLock();
    //写锁
    Lock writeLock = new ReentrantReadWriteLock().writeLock();
    /**
     * 1.线程的间同的通讯类
     * 2.Condition condition = lock.newCondition();
     * 等待状态
     * condition.await();
     * 唤醒其他线程
     * condition.notify();
     * condition.notifyAll();
     */
    //
    Condition condition = lock.newCondition();

    //线程池
    ExecutorService executorService = Executors.newWorkStealingPool();
    ExecutorService executorService1 = Executors.newCachedThreadPool();
    ExecutorService executorService2 = Executors.newFixedThreadPool(10);
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

5.2线程池

创建方式

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

七个参数

一、corePoolSize 线程池核心线程大小

线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。

二、maximumPoolSize 线程池最大线程数量

一个任务被提交到线程池以后，首先会找有没有空闲存活线程，如果有则直接将任务交给这个空闲线程来执行，如果没有则会缓存到工作队列（后面会介绍）中，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。

三、keepAliveTime 空闲线程存活时间

一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定

四、unit 空闲线程存活时间单位

keepAliveTime的计量单位

五、workQueue 工作队列

新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

①ArrayBlockingQueue

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

②LinkedBlockingQuene

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

③SynchronousQuene

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

④PriorityBlockingQueue

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

六、threadFactory 线程工厂

创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等

七、handler 拒绝策略

当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：

①CallerRunsPolicy
该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

②AbortPolicy
该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

③DiscardPolicy
该策略下，直接丢弃任务，什么都不做。

④DiscardOldestPolicy
该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

chenyipengAI

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JAVA基础

Java基础知识汇总1.java的jvm内存JVM虚拟机器结构虚拟机的结详细结构虚拟机栈详细结构虚拟机堆的详细结构虚拟机堆栈关系结构虚拟机中堆对象的详细结构虚拟机中的方法区所存储的内容 1类信息,包括类名(包名+类名),直接父类的完整有效名,修饰符,直接接口的列表 2方法名称,参数列表和类型,方法的返回类型,方法的名称,,操作数栈, 3局部变量表以及大小异常表 4.运行时常量池1.1java的类成员加载的过程1.1
复制链接

扫一扫