32.原子性

2.4 原子性

概述 : 所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

代码实现 :

package com.itheima.threadatom;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            count++;
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}

代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断

 

2.5 volatile关键字不能保证原子性

volatile关键字：

　　只能保证线程每次使用共享数据的时候是最新值，不能保证原子性

解决方案 : 我们可以给count++操作添加锁，那么count++操作就是临界区中的代码，临界区中的代码一次只能被一个线程去执行，所以count++就变成了原子操作。

AtomDemo

package com.itheima.threadatom2;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom=new MyAtomThread();
        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

　　MyAtomThread

package com.itheima.threadatom2;

public class MyAtomThread implements Runnable{
    private volatile int count=0;//送冰激凌的数量
    private Object lock=new Object();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1.从共享数据中读取数据到本线程中
            //2.修改本线程栈中变量副本的值
            //3.会把本线程栈中的变量副本的值赋值给共享数据
            synchronized (lock) {
                count++;
                System.out.println("已经送了"+count+"个冰激凌");
            }
        }

    }
}

2.6 原子性_AtomicInteger

概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变

量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解

使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：

AtomicBoolean： 原子更新布尔类型

AtomicInteger： 原子更新整型

AtomicLong： 原子更新长整型

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

public AtomicInteger()：	   			    初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)：  初始化一个指定值的原子型Integer

int get():   			 				获取值
int getAndIncrement():      			 以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet():     				 以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data):				 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):   			 以原子方式设置为newValue的值，并返回旧值。

　　代码实现

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：	               初始化一个默认值为0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }

}

　　代码2

package com.itheima.threadatom3;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo2 {
    //    public AtomicInteger()：	               初始化一个默认值为0的原子型Integer
    //    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    //int get():   			 				获取值
    //int getAndIncrement():      			 以原子方式将当前值加1，注意，这里返回的是自增前的值。
    //int incrementAndGet():     				 以原子方式将当前值加1，注意，这里返回的是自增后的值。
    //int addAndGet(int data):				 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
    //int getAndSet(int value):   			 以原子方式设置为newValue的值，并返回旧值。
    public static void main(String[] args) {
//        AtomicInteger ac1=new AtomicInteger(12);
//        System.out.println(ac1.get());
//        AtomicInteger ac2=new AtomicInteger(12);
//        System.out.println(ac2.getAndIncrement());
//        System.out.println(ac2.get());
//
//        AtomicInteger ac3=new AtomicInteger(12);
//        System.out.println(ac3.incrementAndGet());//自增后的值

        AtomicInteger ac4=new AtomicInteger(12);
        System.out.println(ac4.addAndGet(20));//自增后的值

        AtomicInteger ac5=new AtomicInteger(12);
        System.out.println(ac5.getAndSet(20));//自增后的值
        System.out.println(ac5.get());
    }
}

2.7 AtomicInteger-内存解析

AtomicInteger原理 : 自旋锁 + CAS 算法

CAS算法：

 

有3个操作数（内存值V， 旧的预期值A，要修改的值B）

当旧的预期值A == 内存值 此时修改成功，将V改为B

当旧的预期值A！=内存值 此时修改失败，不做任何操作

并重新获取现在的最新值（这个重新获取的动作就是自旋）

小结

在修改共享数据的时候，把原来的旧值记录下来了

如果现在内存中的值跟原来的旧值一样，证明没有其他线程操作过内存值，则修改成功

如果现在内存中的值跟原来的旧值不一样了，证明已经有其他线程操作过内存值了。

则修改失败，需要获取现在最新的值，再次进行操作，这个重新获取就是自旋。

2.8 AtomicInteger-源码解析

代码实现 :

package com.itheima.threadatom4;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom=new MyAtomThread();
        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

MyAtomThread

package com.itheima.threadatom4;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomThread implements Runnable{
    //private volatile int count=0;//送冰激凌的数量
    //private Object lock=new Object();
    AtomicInteger ac=new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1.从共享数据中读取数据到本线程中
            //2.修改本线程栈中变量副本的值
            //3.会把本线程栈中的变量副本的值赋值给共享数据
            //synchronized (lock) {
//                count++;
            int count = ac.incrementAndGet();
            System.out.println("已经送了"+count+"个冰激凌");
            //}
        }

    }
}

源码解析 :　　

//先自增，然后获取自增后的结果
public final int incrementAndGet() {
        //+ 1 自增后的结果
        //this 就表示当前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}

public final int getAndAddInt(Object o, long offset, int delta) {
        //v 旧值
        int v;
        //自旋的过程
        do {
            //不断的获取旧值
            v = getIntVolatile(o, offset);
            //如果这个方法的返回值为false，那么继续自旋
            //如果这个方法的返回值为true，那么自旋结束
            //o 表示的就是内存值
            //v 旧值
            //v + delta 修改后的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
            //                                 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
            //如果修改失败，那么继续自旋。
        return v;
}

2.9 悲观锁和乐观锁

synchronized和CAS的区别 :

相同点：在多线程情况下，都可以保证共享数据的安全性。

不同点：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每 次操作共享数据之前，都会上锁。（悲观锁）

cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。

如果别人修改过，那么我再次获取现在最新的值。

如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）

 

3. 并发工具类

3.1 并发工具类-Hashtable

Hashtable出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

代码实现 :

package com.itheima.mymap;

import java.util.HashMap;
import java.util.Hashtable;

public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String ,String> hm=new Hashtable<>();
        Thread t1=new Thread(()->{
            for (int i = 0; i < 25; i++) {
                hm.put(i+"",i+"");
            }
        });

        Thread t2=new Thread(()->{
            for (int i = 25; i < 51; i++) {
                hm.put(i+"",i+"");
            }
        });
        t1.start();
        t2.start();

        System.out.println("-----------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);

        //0-0 1-1......50-50
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i+""));
        }//0 1 2 3.....50
    }
}

　　

根据键的哈希值计算出应存入的索引

1.Hashtable采取悲观锁synchronized的形式保证数据的安全性

2.只要有线程访问，会将整张表全部锁起来，所以Hashtable 的效率低下

3.2 并发工具类-ConcurrentHashMap基本使用

ConcurrentHashMap出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。

体系结构 :

总结 :

1 ，HashMap是线程不安全的。多线程环境下会有数据安全问题

2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下

3，ConcurrentHashMap也是线程安全的，效率较高。 在JDK7和JDK8中，底层原理不一样。

代码实现 :

package com.itheima.mymap;

import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

public class MyCuncurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String ,String> hm=new ConcurrentHashMap<>();
        Thread t1=new Thread(()->{
            for (int i = 0; i < 25; i++) {
                hm.put(i+"",i+"");
            }
        });

        Thread t2=new Thread(()->{
            for (int i = 25; i < 51; i++) {
                hm.put(i+"",i+"");
            }
        });
        t1.start();
        t2.start();

        System.out.println("-----------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);

        //0-0 1-1......50-50
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i+""));
        }//0 1 2 3.....50
    }
}

3.3 并发工具类-ConcurrentHashMap1.7原理

 创建对象：1.默认创建一个长度16，加载因子为0.75的大数组

这个大数组一旦创建无法扩容

2.还会创建一个长度为2的小数组，把地址值赋值给0索引处

其他索引位置的元素都是null

添加：1.第一次会根据键的哈希值来计算出在大数据中应存入的位置。

如果为null，则按照模板创建小数组

　　　　　　创建完毕，会二次哈希，计算出在小数组中应存入的位置

　　　　　　直接存入。

如果不为null，就会根据记录的地址值找到小数组

　　　　　　二次哈希，计算出在小数组应存入的位置

　　　　　　如果需要扩容，则将小数组库扩容两倍

　　　　　　如果不需要扩容，则就会看小数组的这个位置没有元素

　　　　　　　　　　如果没有元素，则直接存

　　　　　　　　　　如果有元素，就会调用equals方法，比较属性值

　　　　　　　　　　　　如果equals为true，则不存

　　　　　　　　　　　　如果equals为false，形成哈希桶结构

3.4 并发工具类-ConcurrentHashMap1.8原理

底层结构：哈希表。（数组，链表，红黑树的结合体）

结合CAS机制+synchronized同步代码块形式保证线程安全。

总结 :

1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。 在第一次添加元素的时候创建哈希表

2，计算当前元素应存入的索引。

3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。

4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。

5，当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性

3.5 并发工具类-CountDownLatch

CountDownLatch类 :

方法	解释
public CountDownLatch(int count)	参数传递线程数，表示等待线程数量
public void await()	让线程等待
public void countDown()	当前线程执行完毕

使用场景： 让某一条线程等待其他线程执行完毕之后再执行

代码实现 :

ChileThread1：

package com.itheima.mycountdowmlatch;

import java.util.concurrent.CountDownLatch;

public class ChildThread1 extends Thread{
    private CountDownLatch countDownLatch;
    public ChildThread1(CountDownLatch countDownLatch) {
        this.countDownLatch=countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName()+"再吃第"+i+"个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

ChileThread2：　　

package com.itheima.mycountdowmlatch;

import java.util.concurrent.CountDownLatch;

public class ChildThread2 extends Thread{
    private CountDownLatch countDownLatch;
    public ChildThread2(CountDownLatch countDownLatch) {
        this.countDownLatch=countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName()+"再吃第"+i+"个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

ChileThread3：　　

package com.itheima.mycountdowmlatch;

import java.util.concurrent.CountDownLatch;

public class ChildThread3 extends Thread{
    private CountDownLatch countDownLatch;
    public ChildThread3(CountDownLatch countDownLatch) {
        this.countDownLatch=countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName()+"再吃第"+i+"个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

MotherThread

package com.itheima.mycountdowmlatch;

import java.util.concurrent.CountDownLatch;

public class MotherThread extends Thread{
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch=countDownLatch;
    }

    @Override
    public void run() {
        //1.等待
        try {
            //当计数器变成0的时候，会自动唤醒这里等待的线程。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("妈妈在收拾碗筷");
    }
}

MyCountDownLatchDemo

package com.itheima.mycountdowmlatch;

import java.util.concurrent.CountDownLatch;

public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.创建CountDownLatch的对象，需要传递给四个线程
        //在底层就定义了一个计数器，此时计数器的值就是3

        CountDownLatch countDownLatch=new CountDownLatch(3);
        //2.创建四个线程对象并开启他们
        MotherThread motherThread=new MotherThread(countDownLatch);
        motherThread.start();
        ChildThread1 t1=new ChildThread1(countDownLatch);
        t1.setName("小明");

        ChildThread2 t2=new ChildThread2(countDownLatch);
        t1.setName("小红");

        ChildThread3 t3=new ChildThread3(countDownLatch);
        t1.setName("小刚");
        t1.start();
        t2.start();
        t3.start();


    }
}　

使用场景：

　　让某一条线程等待其他线程执行完毕后在执行

1. CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。

2. await()：让线程等待，当计数器为0时，会唤醒等待的线程

3. countDown()： 线程执行完毕时调用，会将计数器-1。

3.6 并发工具类-Semaphore

使用场景 :

可以控制访问特定资源的线程数量。

实现步骤 :

1，需要有人管理这个通道------------------创建Semaphore对象

2，当有车进来了，发通行许可证----------acquire()发通行证

3，当车出去了，收回通行许可证----------release()收回通行证

4，如果通行许可证发完了，那么其他车辆只能等着

代码实现 :

package com.itheima.mysemaphore;

import java.util.concurrent.Semaphore;

public class MyRunnable implements Runnable{
    //获得管理员对象
    Semaphore semaphore=new Semaphore(2);
    @Override
    public void run() {
        //获得通行证
        try {
            semaphore.acquire();
            //开始行驶
            System.out.println("获得了通行证，开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");
            //归还通行证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }



    }
}

　　测试类

package com.itheima.mysemaphore;

public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr=new MyRunnable();
        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}