精华内容
下载资源
问答
  • java多线程项目实战
    千次阅读
    2020-07-08 11:25:17

    项目中其实很多方面都要用多线程,前提说一下多线程一些实现和介绍,最后项目实力,废话不多说,开始

    创建线程有哪几种方式?

    • 继承Thread类创建线程类。
    • 通过Runnable接口类创建线程类。
    • 通过Callable和Future创建线程。

    说一下 runnable 和 callable 有什么区别?

    1)Runnable提供run方法,不会抛出异常,只能在run方法内部处理异常。Callable提供call方法,直接抛出Exception异常,也就是你不会因为call方法内部出现检查型异常而不知所措,完全可以抛出即可。
    2)Runnable的run方法无返回值,Callable的call方法提供返回值用来表示任务运行的结果
    3)Runnable可以作为Thread构造器的参数,通过开启新的线程来执行,也可以通过线程池来执行。而Callable只能通过线程池执行。

    线程有哪些状态?

    • NEW: 新建状态,线程对象已经创建,但尚未启动
    • RUNNABLE:就绪状态,可运行状态,调用了线程的start方法,已经在java虚拟机中执行,等待获取操作系统资源如CPU,操作系统调度运行。
    • Running:就绪状态的线程获取到了CPU
    • BLOCKED:堵塞状态。线程等待锁的状态,等待获取锁进入同步块/方法或调用wait后重新进入需要竞争锁
    • WAITING:等待状态。等待另一个线程以执行特定的操作。调用以下方法进入等待状态。 Object.wait(), Thread.join(),LockSupport.park
    • TIMED_WAITING: 线程等待一段时间。调用带参数的Thread.sleep, objct.wait,Thread.join,LockSupport.parkNanos,LockSupport.parkUntil
    • TERMINATED:进程结束状态。

    sleep() 和 wait() 有什么区别?

    • 每个对象都有一个锁来控制同步访问,Synchronized关键字可以和对象的锁交互,来实现同步方法或同步块。sleep()方法正在执行的线程主动让出CPU,在sleep指定时间后CPU再回到该线程继续往下执行(注意:sleep方法只让出了CPU,而并不会释放同步资源锁!!!);wait()方法则是指当前线程让自己暂时退让出同步资源锁,以便其他正在等待该资源的线程得到该资源进而运行,只有调用了notify()方法,之前调用wait()的线程才会解除wait状态,可以去参与竞争同步资源锁,进而得到执行。(注意:notify的作用相当于叫醒睡着的人,而并不会给他分配任务,就是说notify只是让之前调用wait的线程有权利重新参与线程的调度)
    • sleep()方法可以在任何地方使用;wait()方法则只能在同步方法或同步块中使用;
    • sleep()是线程线程类(Thread)的方法,调用会暂停此线程指定的时间,但监控依然保持,不会释放对象锁,到时间自动恢复;wait()是Object的方法,调用会放弃对象锁,进入等待队列,待调用notify()/notifyAll()唤醒指定的线程或者所有线程,才会进入锁池,再次获得对象锁才会进入运行状态;
    • sleep()方法必须捕获异常,而wait()、notify()、notifyAll()不需要捕获异常。

    线程的 run()和 start()有什么区别?

    run()相当于线程的任务处理逻辑的入口方法,它由Java虚拟机在运行相应线程时直接调用,而不是由应用代码进行调用。
    而start()的作用是启动相应的线程。启动一个线程实际是请求Java虚拟机运行相应的线程,而这个线程何时能够运行是由线程调度器决定的。start()调用结束并不表示相应线程已经开始运行,这个线程可能稍后运行,也可能永远也不会运行。start()会先调用JVM_StartThread,再调用thread_entry,最后调用run()。

    -------------------------------------------------------------------------------------------------------------------------------------------------

    废话不多说项目实例

    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.Future;
    
    
    
    public class ThreadTask implements Callable<List<obj>>{
        private List<obj> firstList;
        private List<obj> secondList;
        private List<obj> thirdList;
        private Integer type = 0;
    
        
        public ThreadTask (List<> firstList,List<CredtRaPO> secondList,List<> thirdList){
            this.firstList = firstList;
            this.secondList = secondList;
            this.thirdList=thirdList;
            this.type = 0;
        }
        
    
    
        @Override
        public List<BondPO> call() throws Exception {
            // TODO Auto-generated method stub
          
                for (BondPO bondPO : firstList) {
                    
                    String bondId = bondPO.getBondId();
                    ArrayList<CredtRaPO> CredtRaPOListarr = new ArrayList<>();
                    ArrayList<> unifysctycrdtcdepoarr = new ArrayList<>();
                    for (CredtRaPO credtRaPO : secondList) {
                        
                        if(bondId.equals(obj.getBondBscInfoId())){
                         CredtRaPOListarr.add(credtRaPO);
                        }
                    
                    }
                    bondPO.setCredtRaPOList(CredtRaPOListarr);
                    
                    String issrId = obj.getIssrId();
                    for (obj obj: thirdList) {
                       if(issrId.equals(obj.getPubCompuuid())){
                        unifysctycrdtcdepoarr.add(obj);
                          }
                   }
                       obj.setUnifySctyCrdtCdePOList(unifysctycrdtcdepoarr);
                   }
                    
                  
       
            return firstList;
        }
    
    }

     

      

    
        private Page<BondPO> findPage( OrderBy orderBy, int pageSize, int pageNo, GroupBy groupBy) {
            Page<obj> ipage = new Page<obj>();
         
          
                
                //线程池(future,callable)
                //固定大小线程池
                ExecutorService threadPool = new ThreadPoolExecutor(5, 100,
                        0, TimeUnit.SECONDS,
                        new ArrayBlockingQueue<>(512), // 使用有界队列,避免OOM
                        new ThreadPoolExecutor.DiscardPolicy());
                //线程管理mapList<CredtRaPO>
                 List<Future<List<obj>>> futureList = new ArrayList<Future<List<obj>>>();
                 List<obj> CredtRaPOList = getSqlSessionTemplate().selectList(getNamespace() + ".findPagezxpj");
                 List<obj> UnifySctyCrdtCdePOList = getSqlSessionTemplate().selectList(getNamespace() + ".findPageFxr");
                for (int i = 0; i % 10000 == 0; i+=10000) {
                    //查询
                    int pageSizes=i+10000;
                    int pageNos=i;
                    System.out.println(i);
                    int startRow = pageSizes * (pageNos - 1) + 1;
                    int endRow = pageSizes * pageNos;
                    int offset = pageSizes * (pageNos - 1);
                    params.put("startRow", Integer.valueOf(i));
                    params.put("endRow", Integer.valueOf(i+10000));
                    params.put("offset", (i > 0) ? i+1:0);//三目运算符);
                    params.put("limit", 10000);
                    List<BondPO> poitems = getSqlSessionTemplate().selectList(getNamespace() + ".findPage", params);
                    if(poitems.size()==0){
                        break;
                    }
                    
                    ThreadTask task1 = new ThreadTask(poitems,CredtRaPOList,UnifySctyCrdtCdePOList);
                    Future<List<BondPO>> future1 = threadPool.submit(task1);
                    
                    futureList.add(future1);
                    
                    //开线程
                    //做计算,同时拿到返回的线程类
                    //线程类添加到管理map中
                }
                //遍历线程管理map拿到当前开启的每一个线程
                //调用get方法获取线程执行结果
                //汇总多个线程的计算结果
                List<BondPO> poitemsss=new ArrayList<BondPO>();
                for(Future<List<BondPO>> future:futureList){
                    try {
                        List<BondPO> list = future.get();
                        for (BondPO bondPO : list) {
                            poitemsss.add(bondPO);
                        }
                 
                        
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //关闭线程池
                threadPool.shutdown();
                
                
          
                
                
                ipage.setPageList(poitemsss);
    
          
            }
            // 2 return
            return ipage;
        }

     

    更多相关内容
  • Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化,即在一块芯片上集成多个处理器内核(Core),多核处理器(Multicore Processor)离我们越来越近了――如今...
  • Java 高并发编程相关知识, 接下来将阅读该书, 并且进行比较详细的总结, 好记性不如烂笔头, 加油。 Java 多线程编程实战指南。
  • 详细的讲解了java多线程的原理,并配有代码进行实战,适合java初学者和想对多线程有进一步了解的人。
  • 汪文君JAVA多线程编程实战(完整不加密),连接挂了留言, 我补
  • Java多线程编程实战指南-核心篇Java多线程编程实战指南-核心篇
  • Java多线程编程实战指南(设计模式篇) 黄文海著 中文pdf扫描版
  • Java多线程编程实战指南(核心篇)》以基本概念、原理与方法为主线,辅以丰富的实战案例和生活化实例,并从Java虚拟机、操作系统和硬件多个层次与角度出发,循序渐进、系统地介绍Java平台下的多线程编程核心技术及...
  • Java多线程编程实战指南设计模式篇.mobi
  • 01、【中级原理】java多线程并发编程入门原理精通视频教程 02、【中级原理专题】java并发编程多线程高级专题课程 03. 【中级原理】高并发编程原理和线程池精通教程 04、【高级原理】Java并发多线程编程基础原理与...
  • 主要介绍了Java多线程编程实战之模拟大量数据同步,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 本书以理论结合示例的方式介绍了多线程常见设计模式。
  • Java多线程编程Java多线程编程Java多线程编程Java多线程编程Java多线程编程Java多线程编程
  • java多线程socket.pdf

    2021-10-07 11:49:18
    java多线程socket.pdf
  • 今天小编就为大家分享一篇关于Java多线程实战之单例模式与多线程的实例详解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • Java多线程编程实战指南(设计模式篇)》源码
  • Java多线程编程实战指南核新篇以及设计篇以及和核新篇的案例代码
  • Java多线程编程实战指南(设计模式篇)》采用Java(JDK1.6)语言和UML 为描述语言,并结合作者多年工作经历的相关实战案例,介绍了多线程环境下常用设计模式的来龙去脉:各个设计模式是什么样的及其典型的实际应用...
  • Java多线程编程实战指南+设计模式篇---------------------------------------
  • 很适合多线程方面的知识的提升。能对java多线程基础有很大的帮助,就是书中的例子太少,源码也少,不适合深入理解探索,不过是本好书。
  • Java-jdk10-最新最全多线程编程实战指南-核心篇
  • Java多线程编程实战指南+设计模式篇(全部),很不错的书,可以多看看
  • Java多线程并发实战

    2017-06-22 09:28:08
    Java多线程并发实战,值得推荐
  •  创建两个新线程而不强加类层次 import java.util.*; class TimePrinter implements Runnable { int pauseTime; String name; public TimePrinter(int x, String n) { pauseTime = x; name = n; } ...
  • 今天小编就为大家分享一篇关于Java多线程实战之交叉打印的两种方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • Java多线程编程实战指南 设计模式篇 Java多线程编程实战指南 设计模式篇
  • Java多线程编程实战指南(核心篇)读书笔记(一)

    万次阅读 多人点赞 2017-07-31 11:17:45
    Java多线程编程实战指南(核心篇)读书笔记


    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/76422930冷血之心的博客)


    博主准备恶补一番Java高并发编程相关知识,接下来将阅读该书,并且进行比较详细的总结,好记性不如烂笔头,加油。

    Java多线程编程实战指南(核心篇)读书笔记(一),主要记录该书前两章的基本概念等知识,后续部分将会持续更新哦~欢迎关注本博客。


    目录:

    Java多线程编程实战指南(核心篇)读书笔记(一)

    Java多线程编程实战指南(核心篇)读书笔记(二)

    Java多线程编程实战指南(核心篇)读书笔记(三)

    Java多线程编程实战指南(核心篇)读书笔记(四)

    Java多线程编程实战指南(核心篇)读书笔记(五)


    1. 走进Java世界中的线程
      1. start方法调用结束并不意味着相应的线程已经开始运行,运行时间有线程调度器决定
      2. 运行结束的线程所占用的资源(如内存空间)会如同其他Java对象一样被JVM虚拟机垃圾回收
      3. 为什么不直接调用run方法?
        1. 如果在某处代码中直接调用某个线程的run方法,那么这个线程的run方法将在当前线程中运行,而不是在其自身线程中运行,违背了创建线程的初衷。
        2. 但是,确实是允许直接调用run方法的。
      4. Thread类实现了Runnable接口
      5. 两种创建线程方式的比较
        1. 继承方式和接口方式,后者属于组合的技术,耦合性更低
        2. 后者的一个Runnable实例可以被多个线程实例共享
        3. 继承的方式创建线程,Java虚拟机会为其分配调用栈空间、内核线程等资源,成本更加昂贵
      6. 线程饥饿:
        1. 某些线程永远得不到运行机会,可能由于优先级使用不当导致。
      7. 守护线程和用户线程:
        1. 用户线程会阻止Java虚拟机的正常停止,一个Java虚拟机只有在其所有的用户线程都运行结束后才能正常停止;
        2. 守护线程则不会影响,一般用来执行一些重要性不是很高的任务,例如用于监视其它线程的运行情况。
        3. 通常情况下,一个线程是否是守护线程或者是用户线程,和其父线程保持一致。
      8. 工作线程(后台线程):
        1. 通常是其父类线程创建来用于专门执行某项特定任务的线程;
      9. 多线程编程的优势:
        1. 提高系统的吞吐率
        2. 提高响应性
        3. 充分利用多核处理器资源
        4. 最小化对系统资源的使用
        5. 简化程序的结构
      10. 多线程编程的风险:
        1. 线程安全
        2. 线程活性
          1. 死锁
          2. 活锁:一个线程一直在尝试某个操作但就是没有进展
        3. 上下文切换
          1. 这是属于额外的资源消耗
        4. 可靠性
    2. 多线程编程的目标与挑战
      1. 串行、并发和并行
        1. 串行:按照顺序执行
        2. 并发:宏观上是同时进行,微观上轮流进行
        3. 并行:严格同时进行
        4. 多线程编程的实质就是将任务的处理方式由串行改为并发,即实现并发化,以发挥并发的优势。
      2. 竞态
        1. 一个计算结果的正确性与实践有关的现象,表现为一个问题,对于同样的输入,程序的输出有时候正确,有时候错误。
        2. 举例:多个线程对共享变量,进行i++操作
        3. 严格定义:
          1. 竞态(Race Condition)是指计算结果的正确性依赖于相对时间顺序或者线程的交错。
        4. 注意:竞态不一定就导致计算结果的不正确,它只是不排除计算结果时而正确,时而错误的可能。
      3. 原子性
        1. 对于涉及到共享变量访问的操作,若该操作从执行线程以外的任意线程来看是不可分割的,那么该操作就是原子操作,该操作具有原子性
        2. 即,其它线程不会“看到”该操作执行了部分的中间结果
        3. Java中实现原子性的两种操作:
          1. 锁(Lock)
          2. CAS(Compare-and-Swap)指令,俗称硬件锁
        4. volatile关键字:
          1. 仅仅能保证变量写操作的原子性,不能保证读写操作的原子性
          2. 所以我们一般说,volatile只能保证可见性,不保证原子性。
      4. 可见性
        1. 多线程环境下,一个线程对于某个共享变量的更新,后续访问该变量的线程可能无法立刻读取到这个更新的结果,这就是不可见的情况。
        2. 可见性就是指一个线程对共享变量的更新的结果对于读取相应共享变量的线程而言是否可见的问题
        3. 可见性和原子性的联系和区别:
          1. 原子性描述的是一个线程对共享变量的更新,从另一个线程的角度来看,它要么完成,要么尚未发生。
          2. 可见性描述一个线程对共享变量的更新对于另一个线程而言是否可见
      5. 重排序:
        1.  重排序举例
          1.   - new Instance()到底发生了什么
            1.   - 分配对象的内存空间
            2.   - 初始化对象instance
            3.   - 设置instance指向刚分配的内存地址
          2.   - 2和3可能发生重排序
        2. 重排序可能导致线程安全问题
        3. 重排序不是必然出现的
      6. 上下文切换:
        1. 一个线程被暂停,即被剥夺处理器的使用权,另外一个线程被选中开始或者继续运行的过程就叫做线程上下文切换
      7. 线程的活性故障:
        1. 死锁(Deadlock)
        2. 锁死(Lockout)
        3. 活锁(Livelock)
        4. 饥饿(Starvation)
      8. 资源争用和调度
        1. 公平调度策略:
          1. 按照申请的先后顺序进行授予资源的独占权
        2. 公平调度策略:
          1. 没有按照先后顺序授予资源的独占权
        3. 非公平调度的解释:
          1. 在该策略中,资源的持有线程释放该资源的时候,等待队列中一个线程会被唤醒,而该线程从被唤醒到其继续执行可能需要一段时间。在该时间内,新来的线程(活跃线程)可以先被授予该资源的独占权。
          2. 如果新来的线程占用该资源的时间不长,那么它完全有可能在被唤醒的线程继续执行前释放相应的资源,从而不影响该被唤醒的线程申请资源。
        4. 非公平调度策略和公平调度策略的优缺点分析:
          1. 非公平调度策略:
            1. 优点:前者吞吐率较高,即单位时间内可以为更多的申请者调配资源;
            2. 缺点:资源申请者申请资源所需的时间偏差可能较大,并可能出现线程饥饿的现象
          2. 公平调度策略:
            1. 优点:适合在资源的持有线程占用资源的时间相对长或者资源的平均申请时间间隔相对长的情况下,或者对资源申请所需的时间偏差有所要求的情况下使用;线程申请资源所需的时间偏差较小;不会出现线程饥饿的现象
            2. 缺点:吞吐率较小



    如果对你有帮助,记得点赞哦~欢迎大家关注我的博客,我会持续更新后续章节学习笔记,可以进群366533258一起交流学习哦~



    本群给大家提供一个学习交流的平台,内设菜鸟Java管理员一枚、精通算法的金牌讲师一枚、Android管理员一枚、蓝牙BlueTooth管理员一枚、Web前端管理一枚以及C#管理一枚。欢迎大家进来交流技术。





         
         

    展开全文
  • 本课程希望能够帮助你建立起一张处理并发问题的全景图,让你能够彻底理解Java多线程编程的本质所在。同时,本课程还会深入介绍技术背后的逻辑关系以及应用场景,助你能够游刃有余地游走在这些技术之中。
  • 它不再提倡一体化的项目设计,而是对项目进行有效的“业务区”(可以简单理解为不同的子系统〉划分,并利用合理的技术对业务性能做出提升和改善,同时又极大地简化了配置文件的使用与 profile配置。总而言之,微架构...

    前言

    微架构的出现,很好地适应了这个时代对快速发展变化的要求。它不再提倡一体化的项目设计,而是对项目进行有效的“业务区”(可以简单理解为不同的子系统〉划分,并利用合理的技术对业务性能做出提升和改善,同时又极大地简化了配置文件的使用与 profile配置。总而言之,微架构是开发之中看起来非常简单的一种实现技术,但简单的背后考究的却是开发者对于开源技术的熟练程度。

    SpringBoot 作为一种Web整合开发框架,很好地解决了Web程序的编写困难,可以更简单、高效地实现 MVC 设计模式。更为重要的是,它可以轻松地整合当前各类主流的开发项目,如消息组件、SQL数据库、NoSQL数据库、邮件服务等,因此能极大地缩短项目的开发周期,更快地响应客户的需求变更。SpringCloud 作为SpringBoot 的延续,可以基于Restful流行架构实现RPC业务中心的搭建,可以基于消息组件实现远程配置动态的抓取,还可以与Docker相结合,采用虚拟化手段实现便捷的云服务管理。可以说,微架构的出现与云时代是密不可分的。

    One:JVM实践思维图(完整版)

    Two: 走近Java

    概述+ Java技术体系+Java发展史+Java虚拟机家族:(Sun Classic/Exact VM、HotSpot VM、Mobile/Embedded VM、BEA JRockit/IBM J9 VM、BEA Liquid VM/Azul VM、Apache Harmony/Google Android Dalvik VM、Microsoft JVM及其他)+展望Java技术的未来+实战:自己编译JDK

    Three:自动内存管理

    Java内存区域与内存溢出异常:运行时数据区域:( 程序计数器+Java虚拟机栈+本地方法栈+ Java堆+方法区+ 运行时常量池+直接内存)tSpot虚拟机对象探秘+实战:OutOfMemoryError异常(Java堆溢+虚拟机栈和本地方法栈溢出+方法区和运行时常量池溢出+本机直接内存溢出)

    **垃圾收集器与内存分配策略:**对象已死?+垃圾收集算法+HotSpot的算法细节实现+经典垃圾收集器+低延迟垃圾收集器+选择合适的垃圾收集器+实战:内存分配与回收策略

    **虚拟机性能监控、故障处理工具:**基础故障处理工具+可视化故障处理工具+HotSpot虚拟机插件及工具

    **调优案例分析与实战:**案例分析:(大内存硬件上的程序部署策略+集群间同步导致的内存溢出+堆外内存导致的溢出错误+外部命令导致系统缓慢+ 服务器虚拟机进程崩溃+ 不恰当数据结构导致内存占用过大+ 由Windows虚拟内存导致的长时间停顿+由安全点导致长时间停顿)

    Four:虚拟机执行子系统

    **类文件结构:**无关性的基石+Class类文件的结构+字节码指令简介+公有设计,私有实现 +Class文件结构的发展

    **虚拟机类加载机制:**类加载的时机+ 类加载的过程+类加载器+Java模块化系统

    虚拟机字节码执行引擎: 运行时栈帧结构+方法调用+动态类型语言支持+基于栈的字节码解释执行引擎

    **类加载及执行子系统的案例与实战:**案例分析:( Tomcat:正统的类加载器架构+ OSGi:灵活的类加载器架构+字节码生成技术与动态代理的实现+Backport工具:Java的时光机器)+实战:自己动手实现远程执行功能

    Five:程序编译与代码优化

    **前端编译与优化:**Javac编译器+Java语法糖的味道(泛型+自动装箱、拆箱与遍历循环+条件编译)+实战:插入式注解处理器

    **后端编译与优化:**即时编译器+提前编译器+编译器优化技术+深入理解Graal编译器

    Six:高效并发

    **Java内存模型与线程:**硬件的效率与一致性+Java内存模型(主内存与工作内存+内存间交互操作+对于volatile型变量的特殊规则 +针对long和double型变量的特殊规则+原子性、可见性与有序性+先行发生原则)+Java与线程(线程的实现+Java线程调度+ 状态转换)+Java与协程

    **线程安全与锁优化:**线程安全(Java语言中的线程安全+线程安全的实现方法)+锁优化(自旋锁与自适应自旋+锁消除+锁粗化+轻量级锁+ 偏向锁)

    JVM面试题

    结尾就提供一些大厂大神技术官的JVM面试题分享。

    希望可以帮助到想进入大厂的朋友,尽一点绵薄之力!

    JVM基础:

    内存管理:

    GC相关:

    更多JVM面试整理:

    读者福利

    读到这的朋友还可以免费领取一份收集的Java进阶知识笔记和视频资料。

    资料免费领取方式:关注后,点击这里即可免费领取

    秋招我借这份PDF的复习思路,收获美团,小米,京东等Java岗offer

    更多笔记分享

    秋招我借这份PDF的复习思路,收获美团,小米,京东等Java岗offer

    秋招我借这份PDF的复习思路,收获美团,小米,京东等Java岗offer

    vydVI-1622522195733)]

    更多笔记分享

    [外链图片转存中…(img-u4sASgQE-1622522195734)]

    [外链图片转存中…(img-jpHJ97Ty-1622522195735)]

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,612
精华内容 33,844
关键字:

java多线程项目实战