Java 多线程分析----CAS操作和阻塞

Posted 上后谈爱情

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 多线程分析----CAS操作和阻塞相关的知识,希望对你有一定的参考价值。

1.原子性的操作:

  CAS --CompareAndSwap(),指的是多个线程进入临界区域中,让多个线程在临界区域上自由的竞争,最后能够保证有一个线程能够胜出,其他没有竞争到的线程可以再一次尝试。最终临界区域上的所有线程都能够线程安全性的完成,这种方式,也叫无锁的方式,在之前的Synchronized中,不允许其他线程进入到临界区域中去进行工作。无锁的方式只能够保证线程的安全性,不同于之前讲的同步机制,因此无法对线程进行有序的调度。CAS编程最主要特色:不需要采用锁的方式对共享的资源(受保护数据)保持线程安全性(最经典的Count++)多个线程执行计数器。

  在直接方法(不采用任何操作条件下)下:

 

View Code

 

输出的结果:从输出的结果中看到,有的线程输出的值是相同的:主要的原因Count++并不是一种原子类型的操作,Count++这个指令中包含了三个部分:读---修改---写入,在这个线程竞争的过程中当有的线程在读共享Count时,刚好有其他线程在这里对Count滴入,最后导致这俩个线程同时对Count进行+1,最后同时写入内存,让我们感觉输出结果一样值

  

pool-1-thread-3线程--3
pool-1-thread-1线程--4
pool-1-thread-4线程--4
pool-1-thread-2线程--3
pool-1-thread-4线程--7
pool-1-thread-1线程--6
pool-1-thread-3线程--5
pool-1-thread-1线程--10
pool-1-thread-1线程--12
pool-1-thread-1线程--13
pool-1-thread-4线程--9
pool-1-thread-4线程--14
pool-1-thread-4线程--15
pool-1-thread-2线程--8
pool-1-thread-2线程--16
pool-1-thread-2线程--17
pool-1-thread-2线程--18
pool-1-thread-3线程--11
pool-1-thread-3线程--19
pool-1-thread-3线程--20

解决这种方式第一种加入锁的方法:public synchronized void run()

 1 pool-1-thread-3线程--1
 2 pool-1-thread-3线程--2
 3 pool-1-thread-3线程--3
 4 pool-1-thread-3线程--4
 5 pool-1-thread-3线程--5
 6 pool-1-thread-1线程--6
 7 pool-1-thread-1线程--7
 8 pool-1-thread-1线程--8
 9 pool-1-thread-1线程--9
10 pool-1-thread-1线程--10
11 pool-1-thread-2线程--11
12 pool-1-thread-2线程--12
13 pool-1-thread-2线程--13
14 pool-1-thread-2线程--14
15 pool-1-thread-2线程--15
16 pool-1-thread-4线程--16
17 pool-1-thread-4线程--17
18 pool-1-thread-4线程--18
19 pool-1-thread-4线程--19
20 pool-1-thread-4线程--20

第二中方式采用无锁的机制:采用CAS操作的指令:Atomic类中都有采用这种CAS的机制,采用的是这种非阻塞算法
  原理:CAS包含3个参数:内存位置V,旧值A,新值B,当位置V的值等于A时候cAS 通过原子操作用新值B更新A的操作,用CompareAndSet(A,B)方法进行比较实现CAS操作机制。在原子操作的性质中多采用了这种方式:在循环中不断地去尝试,当成功返回值

 同样在这里这个简单的加加操作,使用jdk中atomic类

 

 1 package JavaConCurrentDemo;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 import java.util.concurrent.atomic.AtomicInteger;
 6 
 7 public class AtomicIntegerDemo implements Runnable{
 8     static AtomicInteger Count=new AtomicInteger();
 9     public void run()
10     {
11         Count.incrementAndGet();
12         System.out.println(Thread.currentThread().getName()+"线程--"+Count);
13     }
14     public static void main(String[] args) {
15         // TODO Auto-generated method stub
16         CountDemo T=new CountDemo();
17         ExecutorService exce=Executors.newFixedThreadPool(4);
18         for(int i=0;i<4;i++)
19         {
20             exce.submit(T);
21         }
22         
23     }
24 }

 

 非阻塞算法:一个线程在失败或者挂起时候不应该影响其他程序的操作::atomic类只是非阻塞算法一个利用,只是简单的加加可以用atomic类实现,在复杂的算法中采用自己编译的非阻塞算法(用底层的原子机器指令(CAS之一))代替锁实现线程的安全(数据的安全性)

 在这基础上采用CompareAndSet代替前面使用到Count.incrementAndGet(),得到一个不重复性的序列

 1 pool-1-thread-1线程--1
 2 pool-1-thread-3线程--2
 3 pool-1-thread-3线程--4
 4 pool-1-thread-1线程--6
 5 pool-1-thread-2线程--5
 6 pool-1-thread-1线程--8
 7 pool-1-thread-4线程--3
 8 pool-1-thread-3线程--7
 9 pool-1-thread-4线程--11
10 pool-1-thread-1线程--10
11 pool-1-thread-1线程--14
12 pool-1-thread-2线程--9
13 pool-1-thread-2线程--15
14 pool-1-thread-4线程--13
15 pool-1-thread-3线程--12
16 pool-1-thread-4线程--17
17 pool-1-thread-4线程--19
18 pool-1-thread-3线程--18
19 pool-1-thread-2线程--16
20 pool-1-thread-2线程--20
 1 package JavaConCurrentDemo;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 import java.util.concurrent.atomic.AtomicInteger;
 6 
 7 public class CounterDemo {
 8     public static class CasCount implements Runnable{
 9         static AtomicInteger Count=new AtomicInteger(0);
10         
11         public void run()
12         {
13         //用increament方法,采用copareandSet代替Count.incrementAndGet();
14             for(int i=0;i<5;i++)
15             {
16                 while(true)
17                 {
18                     if(Count.compareAndSet(Count.get(), Count.get()+1))
19                     {
20                         System.out.println(Thread.currentThread().getName()+"线程--"+Count.get());
21                         break;
22                     }
23                 }
24                 
25                 
26             }
27         }
28 
29     }
30     public static void main(String[] args) {
31         // TODO Auto-generated method stub
32         ExecutorService exce=Executors.newFixedThreadPool(4);
33         for (int i=0;i<4;i++)
34         {
35             exce.submit(new CasCount());
36         }
37     }
38 
39 }

 采用CAS性质进行非阻塞的算法编程,在高并发量确实比锁的的性能要高,但是如果一个线程反复访问某个区域。

  独占锁是一种悲观锁,synchronized就是一种独占锁,它假设最坏的情况,并且只有在确保其它线程不会造成干扰的情况下执行,会导致其它所有需要锁的线程挂起,等待持有锁的线程释放锁。而另一个更加有效的锁就是乐观锁。所谓乐观锁就是,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止

这种乐观的锁叫做无锁,与加锁而言对临界区域是无障碍,通过CAS算法(用多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试)。CAS操作CPU的指令的操作,只有一步原子操作,必须要考线程安全的。

4.CAS操作的问题:

虽然CAS操作能够高效解决原子操作:三个问题:

1.循环时间长开销大。自旋CAS如果长时间不成功,会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升,pause指令有两个作用,第一它可以延迟流水线执行指令(de-pipeline),使CPU不会消耗过多的执行资源,延迟的时间取决于具体实现的版本,在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突(memory order violation)而引起CPU流水线被清空(CPU pipeline flush),从而提高CPU的执行效率。

2.只能保证一个共享变量的原子操作。当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁,或者有一个取巧的办法,就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i=2,j=a,合并一下ij=2a,然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性,你可以把多个变量放在一个对象里来进行CAS操作。如果想要保持多个变量的原子性,采用AtomicReference类来进行封装多个变量,之后对此对象进行CAS操作.

介绍一下JDk.atomic类:

atomicInteger()----主要对待整数

AtomicReference()-----对对象进行原子操作

AtomicIntegerArray[]----对整数数组

3.第三个问题ABA问题----只采用CompareAndSet()方法无法解决ABA问题,加入额外的方法AtomicStampedReference(),能够将CompareAndSet()对变量A修改的次数记录下来。

   ABA问题:线程1想要将变量A的值修改成B,在此之前,出现线程2已经将变量的值由A修改成B在出现一个线程由B修改成A,(变量A的值经过了多次的修改)此时线程1在去对变量进行CAS操作发现变量的值还是A,所以CAS成功(别的线程成功),虽然值相同但是此时值但实际上这时的现场已经和最初不同了。因为在此过程发生了多次的CompareAndSet操作:

下面例子关于自动给手机充费,营业厅免费为手机充值20元一次:在此这个过程类似于ABA操作

 1 package AtomicTest;
 2 
 3 import java.util.concurrent.atomic.AtomicStampedReference;
 4 
 5 public class AtomicStampedReferenceDemo {
 6    static AtomicStampedReference<Integer> moneny=new AtomicStampedReference<Integer>(19,0);
 7     public static void main(String[] args) {
 8         // TODO Auto-generated method stub
 9             //三个充值程序在这里监控,一个消费程序
10         for(int i=0;i<3;i++)//执行三个充值消费监控
11         {    final int timestamp=moneny.getStamp();//第一个参数表示先有余额,第二个参数表示充值次数
12             new Thread()
13             {
14                 //每一个进程有自己的run方法
15                 public void run()
16                 {
17                     while (true)
18                     {
19                         Integer    m=moneny.getReference();
20                         if(m<20)
21                         {
22                             if(moneny.compareAndSet(m,m+20,timestamp,timestamp+1))
23                             {
24                                 System.out.println("余额不足,自动充值20元,现有余额  "+moneny.getReference());
25                                 break;
26                             }
27                             else
28                             {
29                                 System.out.println("以帮你充值一次,无法在送");
30                                 break;
31                             }
32                             
33                         }
34                         else
35                         {
36                             break;
37                         }
38                     }
39                 }
40             }.start();;
41         }
42         //用户模式
43         new Thread(){
44             public void run(){
45                  for(int i=0;i<100;i++)
46                  {
47                      while(true)
48                      {
49                          Integer m=moneny.getReference();
50                          int timestamp=moneny.getStamp();
51                          if(m>10)
52                          {
53                              System.out.println("钱大于10元"+m);
54                              if(moneny.compareAndSet(m,m-10,timestamp,timestamp+1));
55                              {
56                                  System.out.println("消费大于10元 "+moneny.getReference());
57                                     break;
58                              }
59                             
60                          }
61                          else
62                          {//为啥*。getReference会在cas被修改
63                              System.out.println("没有足够的余额");
64                              break;
65                          }
66                      }
67                  }
68             }
69         }.start();
70     }
71     
72 }

 

以上是关于Java 多线程分析----CAS操作和阻塞的主要内容,如果未能解决你的问题,请参考以下文章

CAS(锁)

AtomicInteger源码分析——基于CAS的乐观锁实

Java并发-多线程面试(全面)

JAVA多线程基础

Java CAS 原理分析

多线程