原子

我的上一篇博文讲到了，Volatile不能保证原子性，代码如下： package com . newDemo . controller . test ; import java . util . concurrent . atomic . AtomicInteger ; public class threadDemo15 extends Thread { private volatile static int count = 0 ; //static 修饰的变量，所有的线程都会共享，因为存在在方法区，只会存放一次。 // private static AtomicInteger count = new AtomicInteger(0); //jdk1.5并发包里面的内容 public void run ( ) { for ( int i = 0 ; i < 1000 ; i ++ ) { count ++ ; // count.incrementAndGet(); } System . out . println ( getName ( ) + ";" + count ) ; // System.out.println(getName()+";"+count.get()); } public static void main ( String [ ] args ) {

部分元素核电荷数、名称及其符号 1 氢H 2氦He 3锂Li 4铍Be 5硼B 6 碳C 7氮N 8氧O 9氟F 10氖Ne 11 钠Na 12镁Mg 13铝Al 14硅Si 15磷P 16 硫S 17氯Cl 18氩Ar 19钾K 20钙Ca 21 钪(kàng) Sc 22钛Ti 23钒( f án) V 24铬( g è) Cr 25锰Mn 26 铁Fe 27钴( g ǔ) Co 28镍( ni è) Ni 29铜Cu 30锌Zn 31 镓( ji ā) Ga 32锗( zh ě) Ge 33砷( sh ēn) As 34硒Se 35溴Br 36 氪Kr 47 银Ag 50锡Sn 53碘I 56钡Ba 74钨W 79 金Au 80汞Hg 82铅Pb 第一主族：锂钠钾铷(Rb)铯(Cs)钫(Fr). 稀有气体：氦氖氩氪氙(Xe)氡(Rn). 部分元素常见化合价 钾 钠 银 氢 +1 价 氟 氯 溴 碘 -1 价 钙 镁 钡 锌 +2 价 1 2 铜 2 3 铁 2 4 碳 -2 氧 3 铝 4 硅 5 磷 4 7 锰 -2 4 6 硫 -3 5 氮 原子团 氢氧 根离子 OH - -1 硫 酸根离子 SO 4 2- -2 硝 酸根离子 NO 3 - -1 碳 酸根离子 CO 3 2- -2 碳 酸氢根离子 HCO 3 - -1 铵根离子 NH 4 + +1 氯酸根离子 ClO 3

C++11中的原子操作（atomic operation） 所谓的原子操作，取的就是“原子是最小的、不可分割的最小个体”的意义，它表示在多个线程访问同一个全局资源的时候，能够确保所有其他的线程都不在同一时间内访问相同的资源。也就是他确保了在同一时刻只有唯一的线程对这个资源进行访问。这有点类似互斥对象对共享资源的访问的保护，但是原子操作更加接近底层，因而效率更高。 在以往的C++标准中并没有对原子操作进行规定，我们往往是使用汇编语言，或者是借助第三方的线程库，例如intel的pthread来实现。在新标准C++11，引入了原子操作的概念，并通过这个新的头文件提供了多种原子操作数据类型，例如，atomic_bool,atomic_int等等，如果我们在多个线程中对这些类型的共享资源进行操作，编译器将保证这些操作都是原子性的，也就是说，确保任意时刻只有一个线程对这个资源进行访问，编译器将保证，多个线程访问这个共享资源的正确性。从而避免了锁的使用，提高了效率。 我们还是来看一个实际的例子。假若我们要设计一个广告点击统计程序，在服务器程序中，使用多个线程模拟多个用户对广告的点击： #include <boost/thread/thread.hpp> #include <atomic> #include <iostream> #include <time.h> using namespace

引言 说到多线程,我觉得我们最重要的是要理解一个临界区概念。 举个例子，一个班上1个女孩子（临界区），49个男孩子（线程），男孩子的目标就是这一个女孩子，就是会有竞争关系（线程安全问题）。推广到实际场景，例如对一个数相加或者相减等等情形，因为操作对象就只有一个，在多线程环境下，就会产生线程安全问题。理解临界区概念，我们对多线程问题可以有一个好意识。 Jav内存模型（JMM) 谈到多线程就应该了解一下Java内存模型（JMM）的抽象示意图.下图： 线程A和线程B执行的是时候，会去读取共享变量（临界区），然后各自拷贝一份回到自己的本地内存，执行后续操作。 JMM模型是一种规范，就像Java的接口一样。JMM会涉及到三个问题：原子性，可见性，有序性。 所谓原子性。就是说一个线程的执行会不会被其他线程影响的。他是不可中断的。举个例子: int i=1 这个语句在Jmm中就是原子性的。无论是一个线程执行还是多个线程执行这个语句，读出来的i就是等于1。那什么是非原子性呢，按道理如果Java的代码都是原子性，应该就不会有线程问题了啊。其实JMM这是规定某些语句是原子性罢了。举个非原子性例子： i ++; 这个操作就不是原子性的了。因为他就是包含了三个操作:第一读取i的值，第二将i加上1，第三将结果赋值回来给i，更新i的值。 所谓可见性。可见性表示如果一个值在线程A修改了

volatile的作用 ：对与volatile修饰的变量， 1，保证该变量对所有线程的可见性。 2，禁止指令重排序。 Java内存模型（JMM） 原子性 i = 2; 把i加载到工作内存副本i，副本i=2，把 副本i 刷回主存。是原子的。 j = i; 从主存读 i和j 的副本到工作内存，把副本j=副本i，把副本j刷回主存。不是原子的。 i++; 即i=i+1；从主存读i的副本到工作内存，把副本i的值自增1，把副本i写回主存。不是原子的。 可见性 当一个变量被volatile修饰时，那么对它的修改会立刻刷新到主存，当其它线程需要读取该变量时（对于一条指令只读一次，比如i=i+1，读一次i；而while(flag) 每次判断只读一次，循环3次则读3次。这一点有助于理解volatile保证可见性却对非原子操作的指令i++无效），会去主存中读取最新值。 有序性 double pi = 3.14;//A double r = 1; //B double s= pi * r * r;//C 由于不会影响结果，JMM会对指令重排序，所以执行顺序可能是ABC，也可能是BAC，只要在单线程时不会影响结果。 假设某一指令有volatile变量，则该指令前的所有指令必然在该指令前执行，该指令后的所有指令必然在该指令后执行。 int a = 0; bool flag = false; public

　　说到CAS（CompareAndSwap），不得不先说一说悲观锁和乐观锁，因为CAS是乐观锁思想的一种实现。 　　 　　悲观锁：总是很悲观的认为，每次拿数据都会有其他线程并发执行，所以每次都会进行加锁，用完之后释放锁，其他的线程才能拿到锁，进而拿到资源进行操作。java中的synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。 　　 　　乐观锁：总是很乐观认为，自己拿到数据操作的时候，没有其他线程来并发操作，等自己操作结束要更新数据时，判断自己对数据操作的期间有没有其他线程进行操作，如果有，则进行重试，直到操作变更成功。乐观锁常使用CAS和版本号机制来实现。java中java.util.atomic包下的原子类都是基于CAS实现的。 　　 　　一、什么是CAS 　　 　　CAS指CompareAndSwap，顾名思义，先比较后交换。比较什么？交换什么呢？ 　　 　　CAS中有三个变量：内存地址V，期待值A, 更新值B。 　　 　　当且仅当内存地址V对应的值与期待值A时相等时，将内存地址V对应的值更换为B。 　　 　　二、atomic包 　　 　　有了悲观锁，乐观锁的知识，让我们走进java.util.atomic包，看一看java中CAS的实现。 　　 　　这就是java.util.atomic包下的类，我们着重看AtomicInteger源码

前言 说到 CAS （CompareAndSwap），不得不先说一说 悲观锁 和 乐观锁 ，因为CAS是乐观锁思想的一种实现。 悲观锁 ：总是很悲观的认为，每次拿数据都会有其他线程并发执行，所以每次都会进行加锁，用完之后释放锁，其他的线程才能拿到锁，进而拿到资源进行操作。java中的synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。 乐观锁 ：总是很乐观认为，自己拿到数据操作的时候，没有其他线程来并发操作，等自己操作结束要更新数据时，判断自己对数据操作的期间有没有其他线程进行操作，如果有，则进行重试，直到操作变更成功。乐观锁常使用CAS和版本号机制来实现。java中 java.util.atomic 包下的原子类都是基于CAS实现的。 一、什么是CAS CAS指 CompareAndSwap ，顾名思义， 先比较后交换 。比较什么？交换什么呢？ CAS中有三个变量：内存地址V，期待值A, 更新值B。 当且仅当内存地址V对应的值与期待值A时相等时，将内存地址V对应的值更换为B。 二、atomic包 有了悲观锁，乐观锁的知识，让我们走进java.util.atomic包，看一看java中CAS的实现。 这就是 java.util.atomic 包下的类，我们着重看AtomicInteger源码（其他的都是一样的思想实现的） 然后思考CAS有什么弊端

3. 原子操作与CAS 3.1 原子操作 所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何context switch，也就是切换到另一个线程。 为了实现原子操作，Java中可以通过synchronized关键字将函数或者代码块包围，以实现操作的原子性。但是synchronized关键字有一些很显著的问题： 1、synchronized是基于阻塞锁的机制，如果被阻塞的线程优先级很高，可能很长时间其他线程都没有机会运行； 2、拿到锁的线程一直不释放锁，可能导致其他线程一直等待； 3、线程数量很多时，可能带来大量的竞争，消耗cpu，同时带来死锁或者其他安全。 像synchronized这种独占锁属于悲观锁，它是在假设一定会发生冲突的，那么加锁恰好有用，除此之外，还有乐观锁，乐观锁的含义就是假设没有发生冲突，那么我正好可以进行某项操作，如果要是发生冲突呢，那我就重试直到成功，乐观锁最常见的就是CAS。 JAVA内部在实现原子操作的类时都应用到了CAS。 3.2 CAS CAS是CompareAndSwap的缩写，即比较并替换。CAS需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。 CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作

synchronized和volatile volatile ：保证内存可见性，但是不保证原子性； synchronized：同步锁，既能保证内存可见性，又能保证原子性； synchronized实现可重入锁 (1.持有同一锁自动获取 2.继承锁) 锁定的对象有两种:1.类的实例（对象锁） 2.类对象(类锁) 对象锁（synchronized修饰普通方法或代码块） 对象锁已被其他调用者占用，则需要等待此锁被释放 /** * 对象锁的两种方式 */ //方式一 private int count =10; public synchronized void test01() { count--; System.out.println(Thread.currentThread().getName()+"count="+count); } //方式二 public void test02() { synchronized(this) { count--; System.out.println(Thread.currentThread().getName()+"count="+count); } } 类锁（synchronized修饰静态方法） 所有类实例化对象互斥拥有一把类锁 private static int count =10; /** * 类锁两种表现方式 */ public

1.安全隐患解决－互斥锁 互斥锁使用格式 @synchronized(锁对象) { // 需要锁定的代码 } 注意：锁定1份代码只用1把锁，用多把锁是无效的 互斥锁的优缺点 优点： 能有效防止因多线程抢夺资源造成的数据安全问题 缺点：需要消耗大量的CPU资源 互斥锁的使用前提： 多条线程抢夺同一块资源 相关专业术语： 线程同步 线程同步的意思是：多条线程按顺序地执行任务 互斥锁，就是使用了线程同步技术 2.原子性和非原子性 OC在定义属性时有nonatomic和atomic两种选择 atomic： 原子属性，为setter方法加锁（默认就是atomic） nonatomic： 非原子属性，不会为setter方法加锁 atomic加锁原理 @property (assign, atomic) int age; - (void)setAge:(int)age { @synchronized(self) { _age = age; } } 3.原子性与非原子性的选择 nonatomic和atomic对比 atomic：线程安全，需要消耗大量的资源 nonatomic：非线程安全，适合内存小的移动设备 iOS开发的建议 所有属性都声明为nonatomic 尽量避免多线程抢夺同一块资源 尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力 来源： oschina 链接：