精华内容
下载资源
问答
  • 并发定义

    2019-08-24 14:14:16
    如果逻辑控制流在时间上重叠,那么它们就是并发的。这里提到的逻辑控制流,通俗的讲,就是一次程序操作,比如读取或更新内存中变量的值。

    如果逻辑控制流在时间上重叠,那么它们就是并发的。这里提到的逻辑控制流,通俗的讲,就是一次程序操作,比如读取或更新内存中变量的值。

    展开全文
  • 并发请求不兼容设置 Cannot Make Concurrent Programs Incompatible With Itself (文档 ID 436186.1) --并发程序可执行,对应的“执行方法” SELECT t.lookup_type, t.lookup_code, t.meaning, t.description...
    并发请求不兼容设置
    Cannot Make Concurrent Programs Incompatible With Itself (文档 ID 436186.1)

    --并发程序可执行,对应的“执行方法”
    SELECT t.lookup_type,
           t.lookup_code,
           t.meaning,
           t.description
      FROM fnd_lookup_values t
     WHERE t.language = 'ZHS'
       AND t.lookup_type = 'CP_EXECUTION_METHOD_CODE';

     

    --查询并发请求的参数使用的值集
    SELECT fpv.user_concurrent_program_name,
           fdfc.column_seq_num,
           fdfc.end_user_column_name,
           fdfc.enabled_flag, --启用
           ffvs.flex_value_set_name, --值集
           (SELECT flv.meaning
              FROM fnd_lookup_values_vl flv
             WHERE flv.lookup_type = 'FLEX_DEFAULT_TYPE'
               AND flv.lookup_code = fdfc.default_type) default_type, --默认类型
           fdfc.default_value, --默认值
           fdfc.required_flag, --必需
           (SELECT flv.meaning
              FROM fnd_lookup_values_vl flv
             WHERE flv.lookup_type = 'RANGE_CODES'
               AND flv.lookup_code = fdfc.range_code) range_code, --范围
           fdfc.display_flag, --显示
           fdfc.display_size, --显示大小
           fdfc.maximum_description_len, --说明大小
           fdfc.concatenation_description_len, --级联说明大小
           fdfc.form_left_prompt --提示
      FROM fnd_descr_flex_col_usage_vl fdfc,
           fnd_flex_value_sets         ffvs,
           fnd_concurrent_programs_vl  fpv
    WHERE fdfc.flex_value_set_id = ffvs.flex_value_set_id
       AND substr(fdfc.descriptive_flexfield_name,
                  7, /*'$SRS$.'*/
                  length(fdfc.descriptive_flexfield_name)) =
           fpv.concurrent_program_name
       AND fpv.user_concurrent_program_name IN ('CUX:凭证打印', 'HDSP: 凭证打印')
    --AND ffvs.flex_value_set_name LIKE '%DATE%'
    --fdfc.application_id = 20007 --CUX应用
    ORDER BY fpv.user_concurrent_program_name,
              fdfc.column_seq_num ASC;

     


    程序不兼容有两种类型,“全局”不兼容和“特定于域”的不兼容。

     
    类型(域/全局)
    如果选择“域”,则在特定于域的级别解决不兼容问题。
    如果选择“全局”,则无论该并发程序在哪个域中运行,都将被视为与该并发程序全局不兼容。
     
    程序不兼容有两种类型
    “全局”不兼容和“特定于域”的不兼容。
    您可以将一个并发程序定义为与另一个程序在全局上不兼容-也就是说,这两个程序根本不能同时运行。
    或者您可以将并发程序定义为与冲突域中的另一个程序不兼容。冲突域是数据组的抽象表示。它们可以在不同的域中并行运行。
     
    并发冲突域
    如果将两个程序定义为彼此不兼容,则还必须标识这些程序无法同时访问的数据。
    换句话说,为了防止两个程序同时访问或更新相同的数据,您必须知道就数据而言它们在哪里不兼容。冲突域标识无法同时运行两个不兼容程序的数据
     
    冲突域
    在Oracle应用产品中,数据存储在属于特定应用程序的数据库表中。每个表还可能包含用于确定
    访问各个记录所需满足的条件的信息。这些条件可能包含以下一个或多个数据组:
    * SOB-基于配置文件选项GL_SET_OF_BOOKS
    * Multiple installations(称为MSOB)
    * Multiple Operating units(由配置文件选项MO_OPERATING_UNIT确定)(称为MULTIORG)。
    * Multiple Orgs(由配置文件选项INV_ORGANIZATION_ID确定,由制造应用程序使用)
    * HR may use business group as a conflict resolution domain
    * FA may use FA book
    * ...
    冲突域是用于对数据进行分区的分组的抽象表示。可以定义的域数量没有限制,但是过多的域可能会影响性能。
     
    所有程序在提交时都分配有冲突域。如果将域定义为参数的一部分,则并发管理器将使用它来解决
    不兼容问题。如果该域不是由参数定义的,则并发管理器将使用为配置文件选项Concurrent:Conflicts Domain定义的值。最后,如果程序参数未提供域,并且尚未定义Concurrent:Conflicts域配置文件选项,则使用“标准”域。标准域是所有请求的默认域。
     
    除非为配置文件选项Concurrent:Conflicts Domain定义了值或通过程序参数定义了冲突域,否则所有程序都将使用Standard冲突域。
     
    提交的每个请求都使用参数来标识它将访问的记录。对于使用不兼容规则定义的程序,将使用附加参数(冲突域参数)。可以根据诸如登录ID,账套或用户所在的组织等变量自动设置冲突域。在某些情况下,可以在“提交请求”表单的“参数”字段中选择冲突域参数。确定参数后,冲突解决管理器(CRM)将使用该域来确保不兼容的程序不会在同一域中同时运行。
     
    另请参见配置文件选项:并发:冲突域【Concurrent:Conflicts Domain
    此配置文件为您的数据指定冲突域。冲突域标识了两个不兼容程序无法同时运行的数据。用户可以看到但不能更新此配置文件选项。
     
    展开全文
  • 【并行】 计算机操作系统上的并行,指的是同时...中有多个处理机,则这些可以并发执行的程序便可被分配到多个处理机上,实现并行执行,即利用每个处理机来处理一个可并发执行的程序,这样,多个程序便可以同时执行。

    【并行】
    计算机操作系统上的并行,指的是同时存在于内存中的多道作业都处于运行状态。
    (实际上都是宏观上并行,微观上串行,因为这些作业都是开始各自的运行,但都没运行完毕,只是交替地使用CPU)
    在操作系统中是指,一组程序按独立异步的速度执行,不等同于时间上的重叠(同一个时刻发生),也可以表述为8为数据同时通过并行线进行传送,数据传送速度大大提高,但并行传送的线路长度收到限制,长度增加,干扰会增加,数据出错;

    【并发】

    并发是指:在同一个时间段内,两个或多个程序执行,有时间上重叠(宏观上是同时,围观上仍是顺序执行)。
    在操作系统中,是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序在处理机制上运行。
        在关系数据库中,允许多个用户同时访问和更改共享数据的进程。
        操作系统并发程序执行的特点:
    【并发环境下,由于程序的封闭性被打破,出现了新的特点的】
       1)程序与计算不再一一队形,一个程序副本可以有多个计算;
       2)并发程序之间有相互制约的关系,直接制约体现为一个程序需要另一个程序的计算结果,间接制约体现为多个程序竞争某一资源(如处理机制,缓存区)
       3)并发程序在执行中是走走停停,断续推进的。
    并行,无论是从微观上,还是宏观上,二者都是一起执行的。

    并发,是在同一个CPU上同时(不是真正的同时,而是看来是同时,因为CPU要在多个程序间切换)运行多个程序。

    并行,是每个CPU运行一个程序。

    并发和并行是即相似又有区别的两个概念,并行是指两个或者多个事情在同一时刻发生;

    而并发是指两个或多个事件同一时间间隔内发生。
    在多道程序环境下,并发性是指一段时间内宏观上有多个程序在同时运行,但在单处理机系统中,每一时刻仅有一道程序执行,故微观上这些程序只能是分时地交替执行。倘若在计算机系统
    中有多个处理机,则这些可以并发执行的程序便可被分配到多个处理机上,实现并行执行,即利用每个处理机来处理一个可并发执行的程序,这样,多个程序便可以同时执行。

    展开全文
  • [超级链接:Java并发学习系列-绪论] 在Java并发编程中,如果要保证代码的安全性,则必须保证代码的原子性、可见性和有序性。 在 Java并发12:并发三特性-...原子性定义:一个或多个操作,要么全部执行且在执行过...

    [超级链接:Java并发学习系列-绪论]

    在Java并发编程中,如果要保证代码的安全性,则必须保证代码的原子性、可见性和有序性。

    Java并发12:并发三特性-原子性、可见性和有序性概述及问题示例中,对并发中的三个特性(原子性、可见性和有序性)进行了初步学习。

    本章主要就Java中保障原子性的技术进行更加全面的学习。

    1.整体回顾

    • 原子性定义:一个或多个操作,要么全部执行且在执行过程中不被任何因素打断,要么全部不执行。
    • Java自带原子性:对基本数据类型的变量读取赋值操作是原子性操作。

    2.原子性问题

    由上面的章节已知,不采取任何的原子性保障措施的自增操作并不是原子性的。
    下面的代码实现了一个自增器(不是原子性的)。

    /**
     * <p>原子性示例:不是原子性</p>
     *
     * @author hanchao 2018/3/10 14:58
     **/
    static class Increment {
        private int count = 1;
    
        public void increment() {
            count++;
        }
    
        public int getCount() {
            return count;
        }
    }

    下面的代码展示了在多线程环境中,调用此自增器进行自增操作。

    int type = 0;//类型
    int num = 50000;//自增次数
    int sleepTime = 5000;//等待计算时间
    int begin;//开始的值
    Increment increment;
    //不进行原子性保护的大范围操作
    increment = new Increment();
    begin = increment.getCount();
    LOGGER.info("Java中普通的自增操作不是原子性操作。");
    LOGGER.info("当前运行类:" +increment.getClass().getSimpleName() +  ",count的初始值是:" + increment.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment.getCount());

    某次运行结果:

    2018-03-17 22:52:23 INFO  ConcurrentAtomicityDemo:132 - Java中普通的自增操作不是原子性操作。
    2018-03-17 22:52:23 INFO  ConcurrentAtomicityDemo:133 - 当前运行类:Increment,count的初始值是:1
    2018-03-17 22:52:33 INFO  ConcurrentAtomicityDemo:141 - 进过50000次自增,count应该 = 50001,实际count = 49999

    通过观察结果,发现程序确实存在原子性问题。

    3.原子性技术保障

    在Java中提供了多种原子性保障措施,这里主要涉及三种:

    • 通过synchronized关键字定义同步代码块或者同步方法保障原子性。
    • 通过Lock接口保障原子性。
    • 通过Atomic类型保障原子性。

    3.1.synchronized关键字

    Increment类进行扩展:

    /**
     * <p>原子性示例:通过synchronized保证代码块的原子性</p>
     *
     * @author hanchao 2018/3/10 15:07
     **/
    static class SynchronizedIncrement extends Increment {
        /**
         * <p>添加关键字synchronized,使之成为同步方法</p>
         *
         * @author hanchao 2018/3/10 15:12
         **/
        @Override
        public synchronized void increment() {
            super.count++;
        }
    }

    在多线程环境中进行SynchronizedIncrement 的自增:

    //synchronized关键字能够保证原子性(代码块锁,多线程操作某一对象时,在某个代码块内只能单线程执行)
    increment = new SynchronizedIncrement();
    begin = increment.getCount();
    LOGGER.info("可以通过synchronized关键字保障代码的原子性");
    LOGGER.info("当前运行类:" +increment.getClass().getSimpleName() +  ",count的初始值是:" + increment.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment.getCount());

    运行结果(多次):

    2018-03-18 00:41:30 INFO  ConcurrentAtomicityDemo:147 - 可以通过synchronized关键字保障代码的原子性
    2018-03-18 00:41:30 INFO  ConcurrentAtomicityDemo:148 - 当前运行类:SynchronizedIncrement,count的初始值是:1
    2018-03-18 00:41:40 INFO  ConcurrentAtomicityDemo:156 - 进过50000次自增,count应该 = 50001,实际count = 50001

    通过多次运行,发现运行结果一致,所以可以确定synchronized关键字能够保证代码的原子性

    3.2.Lock接口

    Increment类进行扩展:

    /**
    * <p>原子性示例:通过Lock接口保证指定范围代码的原子性</p>
    *
    * @author hanchao 2018/3/10 15:14
    **/
    static class LockIncrement extends Increment {
       //定义个读写锁:锁内运行多线程读,单线程写
       private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    
       /**
        * <p>运用读写所重写方法</p>
        *
        * @author hanchao 2018/3/10 15:13
        **/
       @Override
       public void increment() {
           //写锁 加锁
           readWriteLock.writeLock().lock();
           try {
               //开始写
               super.count++;
           } finally {
               //将解锁放在finally块中,保证必然执行,防止死锁
               readWriteLock.writeLock().unlock();
           }
       }
    }

    在多线程环境中进行LockIncrement的测试:

    //通过Lock接口保证原子性操作
    increment = new LockIncrement();
    begin = increment.getCount();
    LOGGER.info("可以通过Lock接口保证代码的原子性");
    LOGGER.info("当前运行类:" +increment.getClass().getSimpleName() +  ",count的初始值是:" + increment.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment.getCount());

    运行结果(多次):

    2018-03-18 10:12:12 INFO  ConcurrentAtomicityDemo:163 - 可以通过Lock接口保证代码的原子性
    2018-03-18 10:12:12 INFO  ConcurrentAtomicityDemo:164 - 当前运行类:LockIncrement,count的初始值是:1
    2018-03-18 10:12:29 INFO  ConcurrentAtomicityDemo:172 - 进过50000次自增,count应该 = 50001,实际count = 50001

    通过多次运行,发现运行结果一致,所以可以确定Lock接口能够保证代码的原子性

    3.3.Atomic类型

    Increment类进行扩展:

    /**
    * <p>原子性示例:通过Atomic类型保证类型的原子性</p>
    *
    * @author hanchao 2018/3/10 15:19
    **/
    static class AtomicIncrement {
       private AtomicInteger count = new AtomicInteger(1);
    
       /**
        * <p>无需其他处理,直接自增即可</p>
        *
        * @author hanchao 2018/3/10 15:21
        **/
       public void increment() {
           count.getAndIncrement();
       }
    
       public AtomicInteger getCount() {
           return count;
       }
    }

    在多线程环境中进行AtomicIncrement的测试:

    //通过Atomic变量保证变量操作的原子性
    AtomicIncrement increment1 = new AtomicIncrement();
    begin = increment1.getCount().get();
    LOGGER.info("可以通过Atomic类型保证变量的原子性");
    LOGGER.info("当前运行类:" +increment1.getClass().getSimpleName() +  ",count的初始值是:" + increment1.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment1.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment1.getCount());

    运行结果(多次):

    2018-03-18 10:14:37 INFO  ConcurrentAtomicityDemo:178 - 可以通过Atomic类型保证变量的原子性
    2018-03-18 10:14:37 INFO  ConcurrentAtomicityDemo:179 - 当前运行类:AtomicIncrement,count的初始值是:1
    2018-03-18 10:14:48 INFO  ConcurrentAtomicityDemo:187 - 进过50000次自增,count应该 = 50001,实际count = 50001

    通过多次运行,发现运行结果一致,所以可以确定Atomic类型能够保证代码的原子性

    4.总结

    经验证,以下三种措施,可以保证Java代码在运行时的原子性:

    • synchronized关键字
    • Lock接口
    • Atomic类型

    并发三特性总结

    特性 volatile关键字 synchronized关键字 Lock接口 Atomic变量
    原子性 无法保障 可以保障 可以保障 可以保障
    可见性 可以保障 可以保障 可以保障 可以保障
    有序性 一定程度保障 可以保障 可以保障 无法保障
    展开全文
  • [超级链接:Java并发学习系列-绪论] 在Java并发编程中,如果要保证代码的安全性,则必须保证代码的原子性、可见性和有序性。 在 Java并发12:并发三特性-...可见性定义:当一个线程修改了共享变量的值,其他线程...
  • [超级链接:Java并发学习系列-绪论] 在Java并发编程中,如果要保证代码的安全性,则必须保证代码的原子性、可见性和有序性。 在 Java并发12:并发三特性-...有序性定义:即程序执行的顺序按照代码的先后顺序执行...
  • ---concurrent program define SELECT FCPV.CONCURRENT_PROGRAM_ID, FCPV.CONCURRENT_PROGRAM_NAME, FCPV.USER_CONCURRENT_PROGRAM_NAME, FCPV.EXECUTION_METHOD_CODE, ---p:r...
  • Oracle EBS可执行、并发程序的定义

    千次阅读 2013-12-05 15:59:19
    并发程序的定义 步骤: 一、定义可执行: 1.进入职责应用开发员--并发--可执行; 2.定义可执行:可执行的名称唯一;  简称尽量和可执行名称一致;  应用产品选择要挂的职责,这里选择CUX Customer ...
  • 并发是指在一个时间段内有多个进程在执行。 并行指的是在同一时刻有多个进程在同时执行。 如果是在只有一个CPU的情况下,是无法实现并行的,因为同一时刻只能有一个进程被调度执行,如果此时同时要... 定义: ...
  • 1.ORG_ID 2.DATE 3.YES_NO 转载于:https://www.cnblogs.com/huanghongbo/p/6529549.html
  • 文章目录一、并发的意义二、并发的难点三、java中的线程机制四、如何定义线程任务 一、并发的意义 并发通常是提高运行在单处理机上的程序的性能 这样说的原因是:首先我们会发现在单处理机上运行的并发程序开销应该...
  • 1. 定义Request Set,有两部分构成,Define Stage和Define Link 2. 建立Stage 2-1. 在Stage中建立Program: 定义每一步需运行那个Concurrent Program 2-2. 对Program设定Paremeter: 定义每个Concu...
  • 平均并发用户数公式 C = nL/T 并发用户数峰值公式 C‘ = C + 3*根号C C是平均并发用户数,n是login session的数量,L是login session的平均长度,T是值考察的时间长度 C’是并发用户数峰值 举例1,假设系统A,该...
  • 分布式: ...高并发: 短时间遇到大量请求。 常用解决:html静态化,专门处理图片的服务器,redis分布式缓存,数据库分布等 多线程: 多线程是一门编程技术,解决cpu调度的问题,让多个进程同时执行 ...
  • Java并发(1)-基本定义

    2018-06-16 14:20:58
    引用:参考《Java并发编程的艺术》一书内存屏障(memory barriers)是一组处理器指令,用于实现对内存操作顺序的限制。缓冲行(cache line)缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线,需要...
  • 哎,心累言归正传其实一个网站的并发量我以前也没有注意过毕竟以前公司业务量小基本都是开发管理后台,用的人不多要不就是还没上线就被砍掉(真的很伤,做了多少项目有多少被砍掉)这几次面试问的多就慢慢留意了下 ...
  • Java语言规范第3版中对volatile的定义如下:Java编程语言允许线程访问共享变量,为了确保共享变量能被准确和一致地更新,线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile,在某些情况下比锁要更加...
  • EFcore的并发处理

    千次阅读 2019-05-28 15:01:18
    1.并发定义: 多个线程同时执行一个操作,同时修改数据库的数据,导致数据不一致的情况 2.并发处理 一般情况下,并发处理无非两种,第一种就是加锁:锁的类型,按照思想方法来分,可以分为两种。1.悲观锁。2,...
  • 一、什么是高并发定义: 高并发(High Concurrency)是使用技术手段使系统可以并行处理很多请求。关键指标:-响应时间(Response Time)-吞吐量(Throughput)-每秒查询率QPS(Query Per Second)-每秒事务处理量TPS...
  • 可以将优先级设置在MIN_PRIORITY(在Thread类定义为1)与MAX_PRIORITY(在Thread类定义为10)之间的任何值。线程的默认优先级为NORM_PRIORITY(在Thread类定义为5)。 尽量不要依赖优先级,如果确实要用,应该避免...
  • 并发定义 高并发是指系统在单位时间内处理更多的用户并发请求,也就是承担更大的流量,它是一切系统架构设计的背景和前提。每秒一次请求和每秒一万次请求,两种场景下分别做到毫秒级响应和五个九(99.999%)...
  • golang 基于共享变量的并发

    千次阅读 2018-05-11 16:09:58
    并发定义:当我们没有办法自信地确认一个事件是在另一个事件的前面或者后面发生的话,就说明x和y这两个事件是并发的。并发安全:如果其所有可访问的方法和操作都是并发安全的话,那么类型便是并发安全的。竞争条件:...
  • 怎样才算高并发

    千次阅读 2019-02-20 16:24:58
    定义: 高并发(High Concurrency)是使用技术手段使系统可以并行处理很多请求。 关键指标: -响应时间(Response Time) -吞吐量(Throughput) -每秒查询率QPS(Query Per Second) -每秒事务处理量TPS...
  • 并发

    2012-01-13 19:05:00
     定义:    在操作系统中,是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序在处理机上运行。    ...
  • 本博文由 youngpan1101 出品,转载请注明出处。 文章链接:...作者: 宋洋鹏(youngpan1101) ... ps:该博文是《王健伟老师的:c++11多线程并发视频教程》的课后笔记。 并发 ...定义:两个或者更多的...
  • Runnable定义线程的接口,只有一个run()方法,而且没有返回值。一般通过实现这个接口来定义线程。public interface Runnable { public abstract void run(); } 经常可以用匿名内部类实现: new Thread(new Runnable...
  • 一、定义线程 1、扩展java.lang.Thread类。 此类中有个run()方法,应该注意其用法: public void run() java.lang 类 Thread java.lang.Object  java.lang.Thread 所有已实现的接口: Runnable public...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,952
精华内容 5,580
关键字:

并发定义