精华内容
下载资源
问答
  • 并发程序的特征
    千次阅读
    2022-03-18 08:20:50

    顺序执行时

    1.顺序性:严格的按照顺序执行

    2.封闭性:程序运行时独占全机资源 资源状态只有本程序才能改变它,程序一旦开始执行,不受外界影响

    3.可再现性:无论如何执行 都可缺获得相同的结果

     

    并发执行时

    1.间断性:由于资源有限,并发执行的程序存在相互制约的关系

    2.失去封闭性:并发执行的程序共享计算机资源,这些资源的状态由这些程序改变

    3.不可再现性:并发执行的程序执行的顺序不同可能有不同的执行结果

    更多相关内容
  • 本书主要讲解了一些高并发相关的信息,值得读一读的。。。。
  • 实战Java高并发程序设计主要介绍基于Java的并行程序设计基础、思路、方法和实战。第一,立足于并发程序基础,详细介绍Java中进行并行程序设计的基本方法。第二,进一步详细介绍JDK中对并行程序的强大支持,帮助读者...
  • 随着实际应用对并发软件需求的不断增加,并发程序的应用越来越广,程序切片的研究不再仅仅局限于顺序程序,并发程序切片的研究也越来越多。但是由于并发程序执行的不确定性,并发程序切片的研究还有许多问题有待解决。...
  • 程序并发执行的特征

    千次阅读 2020-10-13 22:14:34
    1:间断性:程序并发执行的时候,因为是共享资源,以及完成同一项任务而相互合作,致使在这些并发执行的程序之间形成了相互制约的关系,导致程序执行呈现:执行--暂停--执行 2:失去封闭性:当系统中有多个并发...

    1:间断性:程序在并发执行的时候,因为是共享资源,以及完成同一项任务而相互合作,致使在这些并发执行的程序之间形成了相互制约的关系,导致程序执行呈现:执行--暂停--执行

    2:失去封闭性:当系统中有多个并发执行的程序时,各个资源是他们所共享的,这些资源的状态也由这些程序所改变,所以摸一个程序的运行环境会受到其他程序的影响。

    3:不可再生性

    展开全文
  • Java并发程序设计教程

    2019-03-14 13:49:35
    Java并发程序设计教程
  • 实战java高并发程序设计 分章 高清 带作业, 葛一鸣等人编著
  • Python编程实战 运用设计模式、并发程序库创建高质量程序.pdf
  • 《实战java高并发程序设计.pdf》,并发,并发,并发。。。
  • java高并发程序设计视频全集,并发场景,死锁,活锁,阻塞,非阻塞...
  • 并发程序的测试

    千次阅读 2022-03-27 18:57:33
    并发的测试并不容易,原因在于并发的不确定性——并发场景下,很多问题无法重现,甚至它还有一个专有的名词,“海森堡错误”。此外,对于Java来说,性能测试经常是比较困难的,这是由于JVM做了太多事,犹如一个黑箱...

    并发的测试并不容易,原因在于并发的不确定性——并发场景下,很多问题无法重现,甚至它还有一个专有的名词,“海森堡错误”。此外,对于Java来说,性能测试经常是比较困难的,这是由于JVM做了太多事,犹如一个黑箱,像垃圾回收,实时编译,提前编译等,对于性能的影响其实很大,要命的事,它们通常不是程序可控的范围,所以需要更加小心。

    正确性测试

    正确性测试有一部分是串行正确性——即,在串行环境下,我们通常考虑的该程序的种种不变性条件。例如初始容量,各种操作等等。这部分就不展开了,也没有什么特殊的。

    阻塞测试

    阻塞是并行程序常见的情况,我们通常利用阻塞来减少空循环造成的开销。然而,阻塞并不好测试——如果程序阻塞来,我就收不到任何反馈;如果程序反馈,说明阻塞失败了;假如程序长时间阻塞,那么我又怎么知道下一刻它不会恢复正常?
    我们会联想到中断机制,利用中断机制,来确定程序是处于阻塞状态。

        void testTakeBlocksWhenEmpty() {
            final BoundedBuffer<Integer> bb = new BoundedBuffer<Integer>(10);
            Thread taker = new Thread() {
                public void run() {
                    try {
                        // 空队列获取元素,阻塞
                        int unused = bb.take();
                        // 如果执行fail(),则表示阻塞失败
                        fail(); // if we get here, it's an error
                    } catch (InterruptedException success) {
                    }
                }
            };
            try {
                taker.start();
                // 主线程sleep一小段时间,保证taker
                Thread.sleep(LOCKUP_DETECT_TIMEOUT);
                // 打断
                taker.interrupt();
                taker.join(LOCKUP_DETECT_TIMEOUT);
                // 如果中断成功,则这里输入false
                assertFalse(taker.isAlive());
            } catch (Exception unexpected) {
                fail();
            }
        }
    

    安全性测试

    思考一个问题,一个生成者-消费者队列,如何测试它的安全性?——每一个生产出来的元素都被正确地放入队列,并且被正确地消费。这看起来似乎不是特别难,但实际上,以上包括数量正确性,元素本身正确性,消费正确性(不会重复),生产正确性(正确入队)。
    可以建立一个影子队列,在生产的时候把每一个元素push进去,在消费的时候,再找到它删除,最后检验是否为空,以及有没有找不到的情况。这当然可以,但问题在于,这个队列是共享资源,而且操作比较重,可想而知会引入大量但同步操作——这本身是不是又使得并发场景发生变化。
    这就成了一个悖论了——为了测试并发程序,我们必然要开发一个并发测试程序,但开发完又会影响原来的并发程序。这有可能引起海森堡错误——假入并发测试程序后测试正常,撤出并发测试程序后就不行了。
    所以,测试并发程序的要点就是:

    尽可能减少并发测试程序引入的资源竞争

    引入校验和就是一个好方法——在生产产品过程中,生成顺序敏感的校验和,然后就可以测试是否正确地生产,消费,顺序是否正确。当然这只针对单生产者-单消费者场景。在多生产者-多消费者的场景下,顺序肯定是无法保证的,所以这个时候的校验和应该是顺序不敏感的。

    // 由于现代编译器比较聪明,常量可能会在编译阶段直接得到结果,因而还需要保证每一次获得的数是随机的,也是不可预测的
    // xorShift结合hashCode,nanoTime作为输入解决这个问题,它非常快速,而且线程安全
    static int xorShift(int y) {
        y ^= (y << 6);
        y ^= (y >>> 21);
        y ^= (y << 7);
        return y;
    }
    
    public class PutTakeTest {
        private static final ExecutorService pool = Executors.newCachedThreadPool();
        private final AtomicInteger putSum = new AtomicInteger(0);
        private final AtomicInteger takeSum = new AtomicInteger(0);
        private final CyclicBarrier barrier;
        private final BoundedBuffer<Integer> bb;
        private final int nTrials, nPairs;
    
        public static void main(String[] args) {
            new PutTakeTest(10, 10, 100000).test(); // sample parameters
            pool.shutdown();
        }
    
        PutTakeTest(int capacity, int npairs, int ntrials) {
            this.bb = new BoundedBuffer<Integer>(capacity);
            this.nTrials = ntrials;
            this.nPairs = npairs;
            this.barrier = new CyclicBarrier(npairs * 2 + 1);
        }
    
        void test() {
            try {
                for (inti = 0; i < nPairs; i++) {
                    pool.execute(new Producer());
                    pool.execute(new Consumer());
                }
                // 阻塞,直到所有生产者消费者就绪,用于确保所有线程并发执行
                barrier.await(); // wait for all threads to be ready
                // 阻塞,直到所有生产者消费者完成,才可以计算校验和
                barrier.await(); // wait for all threads to finish
                assertEquals(putSum.get(), takeSum.get());
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
        /* inner classes of PutTakeTest (Listing 12.5) */
        class Producer implements Runnable {
            public void run() {
                try {
                    // 获得随机种子
                    int seed = (this.hashCode() ^ (int) System.nanoTime());
                    int sum = 0;
                    // 阻塞,直到所有生产者消费者就绪
                    barrier.await();
                    // 生产nTrials个产品
                    for (int i = nTrials; i > 0; --i) {
                        bb.put(seed);
                        sum += seed;
                        seed = xorShift(seed);
                    }
                    // 计算生产校验和,原子操作,竞争很少
                    putSum.getAndAdd(sum);
                    // 阻塞,直到所有线程执行完成
                    barrier.await();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
    
        class Consumer implements Runnable {
            public void run() {
                try
    
                {
                    // 阻塞
                    barrier.await();
                    // 消费
                    int sum = 0;
                    for (int i = nTrials; i > 0; --i) {
                        sum += bb.take();
                    }
                    // 计算消费校验和
                    takeSum.getAndAdd(sum);
                    // 阻塞
                    barrier.await();
                } catch (Exception e) {
                    throw new RuntimeException(e);
    
                }
            }
        }
    }
    
    

    上述代码需要理解CyclicBarrier,它和CountDownLatcher很像,但它支持反复使用——即一次倒计时后,重新归位。上述代码就循环了两次。

    资源管理安全性

    主要是测试资源的申请,释放是否正常。
    典型的例子,例如内存。任何涉及到管理内存的类,都要避免内存泄漏的问题,不适用的引用记得设置为null。
    可以使用一些堆工具获取测试前后的堆变化,这些堆工具会强制执行一次垃圾回收,然后生成一份快照。通过对比两次内存快照就可以判断是否出现内存泄漏。

    注意

    1. 活动线程数量应该大于处理器数量,这样可以尽可能地产生更多的线程交替行为,用于测试并发程序。
    2. 在不同os,处理器,平台上测试可能能获得更全面的结果
    3. 使用Thread.yield有可能能增加更多的交替行为,但该调用的实现是开放性的(可以是空操作)。Thread.sleep更加可靠,但也更慢。

    性能测试

    我们可以想办法测试程序的吞吐量(可以通过总时间/总任务获得平均处理时间,倒数即单位吞吐量)或响应性,结合图表工具来测试并发程序的可伸缩性。例如:
    在这里插入图片描述

    性能陷阱

    前文也提到,Java因为JVM为程序员做了太多事,所以相应也带来很多性能测试方面的不确定性问题。

    • 垃圾回收,无法确定垃圾回收的时机
    • 动态编译,JIT和AOT技术,无法确定哪段代码被编译过,哪段代码是运行时编译
    • 代码路径,代码执行路径不同,同样会影响动态编译
    • 无用的代码消除,JVM编译优化的时候,可能会将没有使用的代码消除调,导致性能测试不符合预期。这个时候可以对这些对象执行一些无意义的空判断,防止被优化掉。
    if (foo.x.hashCode() == System.nanoTime())
        System.out.print(" ");
    
    展开全文
  • EBS 并发程序配置

    千次阅读 2017-01-17 11:52:32
    本文档描述了EBS系统中的并发程序(即请求)和可执行程序的配置步骤,简要的介绍了如何配置一个简单的并发程序的过程。 一般的并发程序配置主要包含以下几个方面: 可执行(非必须)、并发程序、参数(非必须) 其中的并发...

    本文档描述了EBS系统中的并发程序(即请求)和可执行程序的配置步骤,简要的介绍了如何配置一个简单的并发程序的过程。

    一般的并发程序配置主要包含以下几个方面:

    可执行(非必须)、并发程序、参数(非必须)

    其中的并发程序是必须有的,而可执行是可以根据并发程序的不同类型来分别对待的,参数是根据并发程序的实际情况进行配置即可,有就配置,没有就不需要配置了。

    本文档通过配置一个PLSQL类型的并发程序来演示可执行、并发程序以及参数的配置步骤,来演示一个并发程序(请求)的配置过程。

    同时,还会介绍如何将一个请求配置成功能,以便于菜单直接调用。 

    EBS 系统的并发程序配置,主要是在“应用管理员”职责下完成的:


    可执行的配置

    通过“可执行”菜单,进入可执行配置界面,录入相关的可执行信息进行保存即可完成可执行的配置:


    注意:

    a. 可执行的简称必须是唯一标识的英文,如果有模板的话,简称需要和模板的编码一致;

    b. 执行文件需要与对应的执行方法类型匹配,否则容易出错;

    c. 应用产品需要与后边配置的请求组处于同一应用下即可,本文档以“CUX”应用为例进行演示  

    并发程序配置

    通过“程序”菜单进入到并发程序的配置界面,输入相关的并发程序信息以及调用的可执行配置信息,然后保存即可:

    说明:

    a. 并发程序的简称和应用程序配置一般和可执行一致;

    b. 输出格式根据需要进行配置,常用的是文本、XML、HTML三种类型,其中的XML类型主要是和模板一起结合使用的,文本和HTML这两种类型的并发程序可以不需要模板文件;

    c. 如果并发程序有参数信息,则可以通过点击“参数”按钮继续进行配置

     

    参数配置

    通过点击并发程序配置页面的“参数”按钮进行参数信息的配置:

    本示例中只有一个参数,因此配置一个即可。

    该演示并发程序的目的就是输出用户提交并发请求的时候填写的参数信息。

    到此该并发程序的配置基本完成了,只需要在把该并发程序配置到对应的并发请求组里边即可使用了。    

    2.      功能调用并发程序

    一般的并发程序是通过提交请求来执行的,有的时候需要通过点击某个菜单直接调用某个并发程序,因此就需要将对应的并发程序配置成功能,以便于前台菜单进行调用。

    并发功能配置

    调用并发程序的功能配置和普通的功能配置基本类似,只是参数部分略有不同而已,因此功能的配置不在此处过多描述了,直接配置即可:



    说明:

    a.调用并发程序的功能特性类型为“FORM”,调用的表单为“运行报表”

    b.表单页签的参数信息为

    CONCURRENT_PROGRAM_NAME="并发程序简称" PROGRAM_APPL_SHORT_NAME="并发程序应用简称"SUBMIT_ONCE="Y"

    以上即配置了一个 CUX_报表配置演示方法 的功能,直接调用之前配置的“CUX_报表配置演示方法”并发程序

    3.      菜单配置及演示

    将上边的功能配置到对应的应用的某个职责下即可进行演示。

    菜单配置

    此处的菜单配置与一般的菜单配置一致

     

    功能演示

    菜单配置完成之后便可以在前台看到新配置的菜单了:


    直接点击菜单,即可调用之前的并发程序:

     

    展开全文
  • Java并发程序设计+并发
  • 程序并发执行时的特征

    千次阅读 2020-02-13 16:25:28
    间断性。程序并发执行时,由于他们共享资源等原因导致彼此间形成了相互制约的关系。 失去封闭性。 不可再现性。程序并发执行时由于不知道哪个程序会被优先执行导致处理结果可能出现不一致。 ...
  • 面向对象思想写好并发程序

    万次阅读 2022-01-09 22:36:14
    面向对象思想写好并发程序前言一、封装共享变量二、识别共享变量间的约束条件三、制定并发访问策略总结 前言 在工作中很多时候在设计之初都是直接按照单线程的思路来写程序的,而忽略了本应该重视的并发问题;等...
  • java高并发程序设计 pdf 分享

    千次阅读 2019-04-22 18:55:46
    本文章只用于编程学习资料的分享,未做任何盈利行为,如有侵权,提醒删除! 另外,本博客会不定期分享编程学习资料,欢迎关注! 链接:https://pan.baidu.com/s/1eWEitPWk0RUubDoLekN90w 提取码:tsa5 ...
  • 程序并发执行

    千次阅读 2020-03-07 11:16:57
    并发程序的执行和程序顺序执行的特征不同。 并发执行的特征如下: ( 1 )在执行期间并发程序相互制约 ( 2 )程序与计算不再一一对应。 允许多个程序共享一个程序段。 ( 3 )并发程序的执行结果不可再现 并发程序...
  • 在多道批处理系统中,多道程序共享系统资源、并发执行,因此引入了进程的概念。 所以,在学习进程之前有必要先对程序的 顺序执行 和 并发执行方式 做简单的了解。 一、前驱图的概念 所谓前驱后继,其实也就是发生...
  • 四、 程序并发执行

    千次阅读 2020-05-23 16:59:52
    (当图中C1已经数据处理完毕时,I2还没有输入那么C2就得进入暂停,当使C2暂停的因素消失后(I2输入),程序继续执行)由此可见,相互制约将导致并发程序具有“执行—暂停—执行”这种间断性的活动规律 失去封闭性:...
  • 微信小程序并发的个人见解

    千次阅读 2017-10-29 17:01:35
    微信小程序的接口并发处理
  • 并发基础(一)并发的三大特性

    千次阅读 2021-12-29 10:42:11
    1.并行和并发 并行:即同时进行,指在同一时刻,有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看,二者都是一起执行的。 并发:指在同一时刻只能有一条指令执行,但多个进程指令被快速的轮换...
  • 随着多核时代的兴起,现在的服务器CPU可能多达10个以上的内核。...内容将涵盖多线程基础、并发库解析以及高并发程序设计思路等多个方面。 如何写出正确的并行代码,而且是写出高性能的程序,本课程都会给你答案!
  • C#调用httplistener实现简单的http服务器例子:编译后是一个控制台应用程序,启动后,可通过 http://127.0.0.1/ 访问,采用了回调模式提供http服务,支持高并发
  • 只有为程序创建进程后,多个程序才能正确地并发执行。并发是引入进程的目的,也是进程的另一个最基本的特征。 3)独立性。进程实体是一个能够独立运行、独立分配资源和独立接受调度的基本单位。在并发环境中,程序已...
  • 关于这个问题,我觉得咱们今天很有必要好好聊聊“如何用面向对象思想写好并发程序”这个话题。 面向对象思想与并发编程有关系吗?本来是没关系的,它们分属两个不同的领域,但是在 Java 语言里,这...
  • 并发和并行

    千次阅读 2022-03-28 07:49:49
    并发和并行
  • 下面从程序的顺序执行、程序的执行环境和程序并发执行几方面介绍多道程序设计模型。 一、程序的顺序执行 程序是一个在时间上按严格次序前后相继的操作序列,这些操作是机器指令或高级语言编写的语句。人们习惯的...
  • 程序如何防止并发

    千次阅读 2016-06-15 16:11:49
     2、程序处理并发(一般发生在多线程访问)  3、数据库读写并发(一般发生事物之间导致脏读脏写) 二、处理思路  很多情况下,我们遇到并发的问题,往往会寻找技术解决方案。然而很多情况下,我们改变程序处理...
  • wx.request(OBJECT) ...一个微信小程序,同时只能有5个网络请求连接。 ...一个微信小程序,同时只能有5个网络请求...那么,能支持上千个用户同时并发请求吗? 我要做的是需要不断的跟踪用户的定位信息,像滴滴打车那样的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 914,074
精华内容 365,629
关键字:

并发程序的特征