java [内部类]-[异常]-[多线程]-[线程池]

最新推荐文章于 2022-10-27 19:06:59 发布
VIP文章 最新推荐文章于 2022-10-27 19:06:59 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： java基础 文章标签： 内部类 多线程 异常 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VIPGuiBin/article/details/8459410
版权

 

一 内部类

 

  • 内部类的特点:


  1)，内部类可以直接访问外部类的成员，包括私有的
         若内部类将外部类成员变量覆盖，要访问外部类成员变量 采用格式 ：外部类名.this.成员变量
  2)，外部类要访问内部类的成员必须创建内部类对象
  3)，内部类的权限可以是private 默认,protected public  ，外部类只能是public 默认

  4),  内部类能被static 修饰,外部类不可以
  5),  内部类和外部类都可以的final 和 abstract 的

  6),  内部类可以继承其他类和实现其他接口

内部类根据其定义的位置分为成员内部类,局部内部类,匿名内部类

不能位置的内部类能够使用的修饰符和访问范围也各不相同

 

  • 内部类的意义:

    •  -->通过修饰符protected和private来控制访问级别,将一个类中的内部某部分的实现细节隐藏,体现了java封装性
    •  -->内部类对象可以访问创建它的外部类对象的内容，包括私有成员！
    •  -->每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。
            因此，内部类使多重继承的解决方案变得更加完整。集合中的Map.Entry也是内部类的应用

  •  成员内部类的修饰符及访问方式：


  1 , 当内部类定义的外部类成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象
      格式：
     外部类.内部类  引用变量 = new 外部类().new 内部类();

      内部类具有指向外部类的引用,所以能够访问外部类的成员包括私有的

  2,  当内部类定义在成员的位置上被成员修饰符所修饰
    比如

     private 将内部类在外部类中进行封装 除了它的外部类以外其他类中都无法访问。
                 通过这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。 
     static 修饰内部类 内部类就具备static的特性 也叫静态内部类或嵌套类或静态成员类, 静态内部类中

                只能直接访问外部类中的static成员,静态内部类没有了指向外部的引用,出现了访问局限,静态

                的内部类对象不依赖于外部类对象
               

                静态内部类中可以有static字段与静态内部类,静态内部类中的也可以有非静态的成员

                非静态内部类不允许定义静态成员


      内部类其他修饰符:
      public, friendly ,protected,
      也可以将内部类声明为： abstract 和 final


      (a) 在外部的其他类中如何直接访问static内部类非静态成员？


                new Outer.Inner().function();

           通过该方式可以访问到静态的和非静态的成员
     (b) 在外部类其他类中，如何直接访问static内部类的静态成员?
               Outer.Inner.function();

           通过该方式只能访问到静态成员


    注意:
    当内部类中定义了静态成员，该内部类必须是static的
    当外部类中的静态方法访问内部类时，内部类也必须是static的,

    静态只能访问静态 ,非静态可以访问静态也可以访问非静态

 

  •  局部(方法中定义)内部类


    1）局部内部类不能被静态修饰，因为static是成员修饰符，所以局部内部类中不可能有静态成员。

    3)  局部内部类权限只能是默认的,不能是public 或 protected 或 private

    4)  局部内部类可以被final 和 abstract修饰

    5）局部内部类可以直接访问外部类中的成员，因为还持有外部类中的引用，但不可以

         访问它所在的方法的局部变量，只能访问被final修饰的局部变量因为这样可以使变量不再是局部而是全局化
   
    6) 局部内部类只能在所定义的外部类的方法中创建对象 , 不能在其外部类或外部类以外的其他类创建对象

    7) 局部内部类的生命周期跟其所在的外部类方法一样,局部内部类跟方法一样随着外部类的加载而加载,但其中的成员

        变量跟其所在的外部类方法中的局部变量一样在使用到的时候才分配到内存空间,随着方法的调用结束而释放内存

  • 匿名内部类

  • 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或继承一个类以便得到一个实例，没有类名,格式

         new 接口\抽象类(){匿名内部类类体}

  • 匿名内部类是唯一一种无构造方法类(可以添加匿名构造方法)。
  • 匿名类用于继承一个类或是实现接口并得到一个实例， 可以跟普通的实现接口和普通的继承类一样, 可以对继承方法的实现或覆盖,也可以添加新的成员。
  • 匿名内部类不能定义任何静态成员、方法和类。   
  • 匿名内部类不能被权限修饰符public,protected,private 和 static 修饰。  
  • 只能创建匿名内部类的一个实例。
  • 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或继承一个类。  
  • 因匿名内部类为局部内部类，所以跟局部内部类的一样的限制

 

  • 匿名内部类适用于类在定义后马上用到,如:
    • 只是为了获得一个继承来的类的对象或获得一个接口的实现类实例
    • 只是想调用一次一个接口的实现类的一个方法或调用一次继承来的类的一个方法
    • 只是想作为方法的实际参数
    • 类非常小（SUN推荐是在4行代码以下）  

 

  • 定义匿名内部类的前提：内部类必须是且只能继承一个类或者实现了一个接口
     

      

 

二  异常

 

  • 异常的定义:


   程序运行时出现的不正常情况  ,如:想打开的文件不存在、网络连接中断、操作数超出预定范围、正在装载的类文件丢失
   表达式的计算违反了Java语言的语义 内存溢出等

   需要阻止当前方法或作用域继续执行 , java中有异常处理机制

   异常处理机制，就是要告诉开发人员，你的程序出现了不正常的情况，请注意。

 

  • 异常体系

java中所有的异常都由类来表示，所有的异常类都从一个名为Throwable的类派生类出来的。

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。

当发生一个异常时，就会生成 一个Throwable类或其子类的对象。

  • Throwable有两个直接子类：Exception和Error。


   1)对于一般的问题通过Excepttion描述


    程序运行所导致的错误由Exception类来表示，该异常类定义了程序中可能遇到的轻微的错误条件。可以编写代码处理异
    常并继续执行程序，而不是让程序中断。它代表轻微的故障，可以恢复的故障，接收到异常信号后，调用方法捕获抛出的异
    常，在可能时，再恢复回来。这类异常一般由程序员来处理。


   2)对于严重的问题通过error描述


    error类型的异常相关的错误发生在Java虚拟机中，而不是在程序中。Error类定义了被认为是不能恢复的严重错误。在大多数
    情况下，当遇到这样的错误时，建议让该程序中断。这样的异常超出了程序可控制的范围，因此，程序员一般不处理这类异常。

 

  • 运行时Exception 和 编译时 Exception

 

    • 异常的特殊子类异常：运行时异常 RuntimeException
    •  Exception分两种：


   1，编译时被检测到的异常
     函数内抛出编译时异常，函数上必须声明；

     函数上声明编译时异常，调用者必须处理(继续往外抛或try...catch处理).
     抛出去或try{}catch(){}, 否则编译失败。该异常被标识，代表这可以被处理。


   2，编译时不能被检测到的异常（运行时异常，RuntimeException及其子类）
      不用声明的；声明了也不用处理。

    •   RuntimeException 特点：不抛不处理
         
          (1)如果在函数内抛出 RuntimeException 异常(含子类异常)，函数上可以不用声明，编译一样通过。
          (2)如果在函数上声明了 RuntimeException 异常(含子类异常)，调用者可以不处理，编译一样通过。
              对于函数内抛出非 RuntimeException 异常函数上必须做声明
          (3)之所以不用在函数上声明，是因为不需要让调用者处理，只希望程序停止，因为运行时出现了无法
             继续进行的情况，必须对代码修正才行，Java运行系统能自动抛出，处理, 所以调用者可以不抛不处理

 

    • 常见的RuntimeException异常：
         

     ArithmeticException :算术运算异常 
     IndexOutOfBoundsException:角标越界异常 
                          |--ArrayIndexOutOfBoundsException: 数组角标越界异常
                          |_StringIndexOutOfBoundsException:字符串角标越界异常
     ClassCastException:类型转换异常
     NullPointerException ：空指针异常
    SecurityException:安全侵犯异常

  • 自定义异常时，如果该异常的发生，无法再继续进行运算，就让自定义异常继承RuntimeException

 

  •   怎么处理异常呢?


   java在运行时环境发生异常而产生异常对象时,会寻找处理该异常的catch块,如果找到则将该异常对象交给catch块进行处理
   这个过程就捕获异常,如果java运行时环境找不到异常的catch块则运行时环境终止,java程序退出

  •   异常处理机制


  程序中，把需要被检查的代码段放在一个以关键字try开头的代码块中。try代码块如果有异常发生就会抛出该异常。

  若有异常抛出则用catch捕获这个异常，并在catch的语句中加以适当的处理或者可以使用关键字throw手动抛出自定义异常。

  而从一个方法抛出异常必须用throws。异常可能导致一个终止当前方法的错误，造成其方法返回。finally语句块在退出

  try/catch异常处理代码块时执行 ,可以将退出时必须的操作可放在finally代码块中。

  所以finally语句块是一定会执行的无论是否有异常发生 , 除非在try catch中用exit()函数终止程序
  

  •  异常处理语句：
        try
        {
         需要被检测的代码；
        }
        catch (异常类型)
        {
         处理异常的代码；
        }
        finally
        {
         一定会执行的代码(除非在其他地方调用了exit())；//用于关闭释放资源
        }

 

  • 异常处理语句的三种格式


   第一个格式：try{}catch (){}
   第二个格式：try{}catch (){}finally{}
   第三个格式：try{}finally{}

   catch必须配合try使用,finally也必须配合try使用
   

  • catch

catch是用于捕获异常catch块处理异常。如果没有catch就代表异常没有被处理过，
   如果该异常是编译检测时异常。那么必须声明。

   catch中异常信息输出:
   catch(Exception e)
   e.getMessage(); //返回throwable的详细的字符串。
   e.toString(); //返回异常对象名称及异常信息简述
   e.printStackTrace();//返回追踪到的异常位置信息

  •    多异常


1，声明异常时，建议声明更具体的异常，使处理可以更具体

2，对方声明几个异常，就对应有几个catch块，不要定义多余的catch块

3,  如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面

4,  catch处理时。catch一定要定义具体处理方式
     不要简单定义异常信息的提示语句 e.printStackTrace()
     也不要简单的就一条输出语句

最低0.47元/天 解锁文章
之武
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程池概念.txt
08-16
线程安全，并发的知识有加深认知；当然，现在用过的东西并不是代表以后还能娴熟的使用，做好笔记非常重要； 1：必须明白为什么要使用线程池：(这点很重要) 　　a:手上项目所需，因为项目主要的目的是实现多线程的数据推送；需要创建多线程的话，那就要处理好线程安全的问题；因为项目需要，还涉及到排队下载的功能，所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能； 　　b:在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题（这段是摘自网络） 2：如何创建一个线程池： 　　 复制代码 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; } 复制代码 这里只是创建线程池其中的一个构造函数；其实其他的构造函数最终还是调用的这个构造函数； 说明一下这些参数的作用: corePoolSize：核心池的大小，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中; maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；这个参数是跟后面的阻塞队列联系紧密的；只有当阻塞队列满了，如果还有任务添加到线程池的话，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务；如果继续添加任务到线程池，且线程池中的线程数已经达到了maximumPoolSize，那么线程就会就会执行reject操作（这里后面会提及到） keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止；默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用；即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法并设置了参数为true，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的阻塞队列大小为0；（这部分通过查看ThreadPoolExecutor的源码分析--getTask()部分）； unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性（时间单位） workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择　　 　　ArrayBlockingQueue; 　　LinkedBlockingQueue; 　　SynchronousQueue; 　　ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。 threadFactory：线程工厂，主要用来创建线程：默认值 DefaultThreadFactory； handler：表示当拒绝处理任务时的策略，就是上面提及的reject操作；有以下四种取值： 　　ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。（默认handle） 　　ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 　　ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程） 　　ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 3：对线程池的基本使用及其部分源码的分析（注意：这里的源码分析是基于jdk1.6；） a:线程池的状态 volatile int runState; static final int RUNNING = 0; 运行状态 static final int SHUTDOWN = 1; 关闭状态；SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕 static final int STOP = 2;停止状态；此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务 static final int TERMINATED = 3;终止状态；当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态 b:参数再次说明。这是摘自网络的解释，我觉得他比喻的很好，所以这里直接就用它的解释 　　这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。 　　corePoolSize在很多地方被翻译成核心池大小，其实我的理解这个就是线程池的大小。举个简单的例子： 　　假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。 　　因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做； 　　当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待； 　　如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来； 　　然后就将任务也分配给这4个临时工人做； 　　如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。 　　当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。 　　这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。 　　也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量突然过大时的一种补救措施。 　　不过为了方便理解，在本文后面还是将corePoolSize翻译成核心池大小。 　　largestPoolSize只是一个用来起记录作用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。 c:添加线程池任务的入口就是execute(); 复制代码 public void execute(Runnable command) { if (command == null) throw new NullPointerException();//任务为空时抛出异常 //如果线程池线程大小小于核心线程，就新建一个线程加入任务并启动线程 //如果线程池线程大小大于核心线且且添加任务到线程失败，就把任务添加到阻塞队列 if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {//新建线程并启动 if (runState == RUNNING && workQueue.offer(command)) {//添加任务到队列 if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command);//添加到队列失败或已满，做拒接任务处理策略 } //若阻塞队列失败或已满；这里新建一个线程并启动做应急处理（这里就是用到了maximumPoolSize参数） else if (!addIfUnderMaximumPoolSize(command)) reject(command); // 若线程池的线程超过了maximumPoolSize；就做拒绝处理任务策略 } } 复制代码 -->>继续跟踪代码到addIfUnderCorePoolSize(Runnable firstTask)：函数名称就可以看出来这个函数要执行的什么；如果线程池的线程小于核心线程数corePoolSize就新建线程加入任务并启动线程【在今后的开发中尽量把需要做的功能在函数名体现出来】 复制代码 private boolean addIfUnderCorePoolSize(Runnable firstTask) { Thread t = null; final ReentrantLock mainLock = this.mainLock;//获取当前线程池的锁 mainLock.lock();//加锁 try { /* 这里线程池线程大小还需要判断一次；前面的判断过程中并没有加锁，因此可能在execute方法判断的时候poolSize小于corePoolSize，而判断完之后，在其他线程中又向线程池提交了任务，就可能导致poolSize不小于corePoolSize了，所以需要在这个地方继续判断 */ if (poolSize < corePoolSize && runState == RUNNING) t = addThread(firstTask);//新建线程 } finally { mainLock.unlock(); } if (t == null) return false; t.start();//若创建线程超过，就启动线程池的线程 return true; } private Thread addThread(Runnable firstTask) { Worker w = new Worker(firstTask);//worker：ThreadPoolExecutor的内部类； Thread t = threadFactory.newThread(w);//使用线程工厂创建一个线程 if (t != null) { w.thread = t; workers.add(w);//保存线程池正在运行的线程 int nt = ++poolSize;//线程池的线程数加1 if (nt > largestPoolSize) largestPoolSize = nt; } return t; } 复制代码 -->>接下来定位worker类，看看线程池里的线程是如何执行的 上面的addIfUnderCorePoolSize(..)已经把线程启动了；现在就直接查看worker 的run()方法了 复制代码 public void run() { try { Runnable task = firstTask;//该线程的第一个任务，执行完后就从阻塞队列取任务执行 firstTask = null; while (task != null || (task = getTask()) != null) {//getTask()从队列去任务执行 runTask(task);//线程执行任务 task = null; } } finally { workerDone(this);//若任务全部执行完，就开始尝试去停止线程池；这部分代码就不再追踪下去，有兴趣的读者可以自己打开源码分析，不必害怕，学习大神们的编码方式，看源码能让你学习到很多 } } private void runTask(Runnable task) { final ReentrantLock runLock = this.runLock; runLock.lock(); try { //多次检查线程池有没有关闭 if (runState < STOP && Thread.interrupted() && runState >= STOP) thread.interrupt(); boolean ran = false; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务之前的统计工作或者用来保存正在执行的任务 beforeExecute(thread, task); try { task.run(); ran = true; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务完成之后的统计工作或者用来保存正在执行的任务 afterExecute(task, null); ++completedTasks;//统计总共执行的任务数 } catch (RuntimeException ex) { if (!ran) afterExecute(task, ex); throw ex; } } finally { runLock.unlock(); } } 复制代码 至此线程池基本的流程完了； 再说说我在项目中的使用： MyExtendThreadPoolExecutor 继承了 ThreadPoolExecutor，并覆盖了其中的一些方法 复制代码 public class MyExtendThreadPoolExecutor extends ThreadPoolExecutor{ public static Logger logger=LoggerFactory.getLogger(MyExtendThreadPoolExecutor.class); /** * 记录运行中任务 */ private LinkedBlockingQueue<Runnable> workBlockingQueue=new LinkedBlockingQueue<Runnable>(); public MyExtendThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); } @Override protected void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); workBlockingQueue.add((GtdataBreakpointResumeDownloadThread)r);//保存在运行的任务 logger.info("Before the task execution"); } @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); workBlockingQueue.remove((GtdataBreakpointResumeDownloadThread)r);//移除关闭的任务 logger.info("After the task execution"); } /** * * Description: 正在运行的任务 * @return LinkedBlockingQueue<Runnable><br> * @author lishun */ public LinkedBlockingQueue<Runnable> getWorkBlockingQueue() { return workBlockingQueue; } } 复制代码 MyExtendThreadPoolExecutor pool = new MyExtendThreadPoolExecutor(3, 3,60L,TimeUnit.SECONDS,new LinkedBlockingQueue <Runnable>()); //创建线程池 复制代码 public void addToThreadPool(DownloadRecord downloadRecord){ BlockingQueue<Runnable> waitThreadQueue = pool.getQueue();//Returns the task queue LinkedBlockingQueue<Runnable> workThreadQueue =pool.getWorkBlockingQueue();//Returns the running work GtdataBreakpointResumeDownloadThread downloadThread = new GtdataBreakpointResumeDownloadThread(downloadRecord);//需要执行的任务线程 if (!waitThreadQueue.contains(downloadThread)&&!workThreadQueue.contains(downloadThread)) {//判断任务是否存在正在运行的线程或存在阻塞队列，不存在的就加入线程池（这里的比较要重写equals()） Timestamp recordtime = new Timestamp(System.currentTimeMillis()); logger.info("a_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" add to workThreadQueue"); downloadThread.setName("th_"+downloadRecord.getName()); pool.execute(downloadThread);//添加到线程池 }else{ logger.info("i_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" in waitThreadQueue or workThreadQueue"); } }
Java基础：初识线程，进程，了解主线程与创建多线程的两种方式
JinxLin的博客
08-17 437
线程相关概念 并行与并发 概念阶段： 并行：指两个或多个事件在同一时刻发生。同时执行 并发：指两个或多个事件在同一时间段内发生。交替执行 进程与线程 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程； 进程是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。 线程：线程是指进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序可以称之为多线
计算机毕业设计中java多线程与异常处理
bwwork的博客
03-03 175
（一） Thread子类的方法实现多线程 编写 TwoThreadsTest.java 程序文件，源代码如下。 class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { for (int i = 0; i < 10; i++) { System.out.print
Java多线程【线程与线程池】
eee3331的博客
10-27 648
关于Java中线程的创建方式，以及线程池的使用介绍。
创建多线程程序的第一种方式：创建Thread类的子类
weiyoo55的博客
07-01 901
创建Thread类的子类 java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类 实现步骤： 1.创建一个Thread类的子类 2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么） 3.创建Thread类的子类对象 4.调用Thread类中的方法start方法，开启新的线程，执行run方法 void start（)使该线程开始执行;Java虚拟机调用该线程的run方法。 结果是两个线程并发地运行；当前线程（main线程）
Java线程池--为什么使用线程池？优缺点是什么？
IT利刃出鞘的博客
02-06 6638
本文介绍为什么使用线程池以及它的优缺点是什么。
深入理解Java线程池(2)：ThreadPoolExecutor执行任务相关方法，内部类worker
xiaoyuchenCSDN的博客
11-04 692
这次来看看worker线程启动和运行的相关方法。了解任务获取与异常处理机制。 关于线程池参数解释，启动方法解析请移步： https://blog.csdn.net/xiaoyuchenCSDN/article/details/83549068 Worker 先说说Worker类，它作为线程的承载类、任务的执行者，自然少不了实现Rannable接口，在ThreadPoolExecutor的addWo...
【java】匿名内部类和多线程
XiaoChen~Coder
08-12 627
目录匿名内部类和多线程1.匿名内部类1.1接口复习1.2类的本体2.多线程2.1什么是进程2.2什么是线程2.3进程和线程的关系2.4线程优缺点2.5 java中创建线程的两种方式2.6Thread中常用方法2.7 线程锁操作问题2.7.1生活场景分析2.7.2代码实现分析2.7.3售票抢占问题2.7.4同步代码块2.8守护线程/后台进程 匿名内部类和多线程 1.匿名内部类 1.1接口复习 interface A { 成员变量 缺省属性 public static final 定义时必须初始化 成员
多线程中的Join
柯基的博客
09-16 2542
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
java内部学习笔记.docx
02-18
Java技术基础 4 1.1编程语言 4 1.2 Java的特点 4 1.3 Java开发环境 4 1.4 Java开发环境配置 5 1.5 Linux命令与相关知识 5 ...5.12 Thread线程类及多线程 61 5.13 Socket网络编程 65 5.14线程池 67 5.15双缓冲队列 68
Java后端面试问题整理.docx
07-16
• 熟悉Java多线程并发中线程基本方法，线程池，线程生命周期，熟悉Java锁中常见锁分类(乐观/悲观锁、自旋锁、独/共享锁、可重入锁、公平/非公平锁、分段锁、偏向锁，轻/重量级锁)和基本的锁升级策略
Java并发编程（学习笔记）.xmind
06-19
（1）如果设计正确，多线程程序可以通过提高处理器资源的利用率来提升系统吞吐率 （2）建模简单：通过使用线程可以讲复杂并且异步的工作流进一步分解成一组简单并且同步的工作流，每个工作流在一个单独的线程...
java IO流 [缓冲技术] [装饰设计模式]
VIPGuiBin的专栏
01-06 3914
------- android培训、java培训、期待与您交流！   ----------   IO流流的分类字符流的由来乱码的出现读写流流的读写操作WriterReader缓冲技术IO异常装饰设计模式InputStreamReader IO流            IO流---input 和 output 的简写,用来处理设备之间的数据传输 如内存 硬盘 网络等
java 集合架构--[Collection] [List] [Set] [Map] [集合工具类]
VIPGuiBin的专栏
01-04 3668
------- android培训、java培训、期待与您交流！     ----------   数组与集合的共同点和区别集合框架--Set元素存取无序不可重复无索引Iterator 接口Stack 是 Vector的子类泛型Map 接口Collections 类关于数组 集合的总结   一 、集合架构 数组与集合的共同点和区别 相同点：数组或集合都是容器都可
java [字符串]-[StringBuffer]-[正则表达式]
VIPGuiBin的专栏
12-30 3544
------- android培训、java培训、期待与您交流！  ---------- 一字符串  二StringBuffer 与 StringBuilder三正则表达式 一、字符串   String 是一个final类 不能复写 不能有子类 1. 用双引号引起的都是字符串对象 , 该对象位于常量池中   2. 字符串中==与equals的区别   1--> S
java [继承]-[接口]-[抽象类]-[多态]-[Object]
VIPGuiBin的专栏
01-01 3275
------- android培训、java培训、期待与您交流！   ---------- 父类与子类关系继承关系抽象类接口多态  多态的体现多态的前提多态的好处多态的弊端  多态中成员的特点Object 类 父类与子类关系：继承关系   继承通过extends 关键字来声明: 子类 extends 父类  继承的作用 :  继承是子类自动共享父类数据和方法的机
java 网络编程 [网络传输] [协议] [UDP与TCP] [套接字] [URL与URI]
VIPGuiBin的专栏
01-06 3040
------- android培训、java培训、期待与您交流！    ---------- 网络传输通用协议传输过程数据封装过程UDP 和 TCP 区别InetAddressSocket 套接字DatagramPacket 数据报包TCPhttp 请求消息头URI 和 URLURLConnection 网络编程   网络传输 通信双方通过传输介质依据
java多线程基础知识
最新发布
07-28
6. 线程安全类：Java提供了一些线程安全的类，如Vector、Hashtable和ConcurrentHashMap等，可以在多线程环境下安全地操作共享数据。 7. 线程的异常处理：线程内部发生异常时，可以通过捕获异常并进行处理，保证程序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值