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

并发请求不兼容设置

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中保障原子性的技术进行更加全面的学习。

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变量
原子性
  
无法保障
  
可以保障
  
可以保障
  
可以保障
可见性
  
可以保障
  
可以保障
  
可以保障
  
可以保障
有序性
  
一定程度保障
  
可以保障
  
可以保障
  
无法保障