1、原子更新基本类型类

  用于通过原子的方式更新基本类型，Atomic包提供了以下三个类： AtomicBoolean：原子更新布尔类型。 AtomicInteger：原子更新整型。 AtomicLong：原子更新长整型。 AtomicInteger的常用方法如下： int addAndGet(int delta) ：以原子方式将输入的数值与实例中的值 （AtomicInteger里的value）相加，并返回结果 boolean compareAndSet(int expect, int update) ：如果输入的数值等于值，则以原子方式将该值设置为输入的值。 int getAndIncrement()：以原子方式将当前值加1，注意：这里返回的是自前的值。void lazySet(int newValue)：最终会设置成newValue，使用lazySet设置后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。 int getAndSet(int newValue)：以原子方式设置为newValue的值，并返回值。 Atomic包提供了三种基本类型的原子更新，但是Java的基本类型里还有char，fldouble等。那么问题来了，如何原子的更新其他的基本类型呢？Atomic包里的类基本使用Unsafe实现的，Unsafe只提供了三种CAS方法，compareAndSwapObject， compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现先把Boolean转换成整型，再使用compareAndSwapInt进行CAS，所以原子更新dou也可以用类似的思路来实现。

下面我们来看一下每种类型的一个实例：

  1. /**
  2. * <p>Title: AtomicIntegerTest.java</p >
  3. * <p>Description: </p >
  4. * <p>Copyright: NTT DATA Synergy All Rights Reserved.</p >
  5. * <p>Company: www.synesoft.com.cn</p >
  6. * <p>@datetime 2019年8月9日 上午8:01:30</p >
  7. * <p>$Revision$</p >
  8. * <p>$Date$</p >
  9. * <p>$Id$</p >
  10. */
  11. package com.test;
  12.  
  13. import java.util.concurrent.atomic.AtomicInteger;
  14.  
  15. /**
  16.  * @author hong_liping
  17.  *
  18.  */
  19. public class AtomicIntegerTest {
  20.     static AtomicInteger ai=new AtomicInteger();
  21.     public static void main(String[] args) {
  22.         for(int i=0;i<10;i++){
  23.             new Thread(new Runnable() {
  24.  
  25.                 @Override
  26.                 public void run() {
  27.                     ai.incrementAndGet();
  28.  
  29.                 }
  30.             }).start();
  31.         }
  32. //        try {
  33. //            Thread.sleep(100);
  34. //        } catch (InterruptedException e) {
  35. //            e.printStackTrace();
  36. //        }
  37.         System.out.println("循环后的结果如下："+ai.get());
  38.     }
  39.  
  40. }//测试结果循环后的结果如下：9循环后的结果如下：10

根据上面的代码，我们多运行几次，会发现，代码的测试结果一会儿是9一会儿是10，不是10，为什么呢，因为线程还没有跑完，我下面的就已经打出来了，让线程睡眠一下就可以解决这个问题了。

下面我们来看一下atomic的ABA问题，这个问题在面试的时候经常问到。

  1. /**
  2. * <p>Title: AtomicTest.java</p >
  3. * <p>Description: </p >
  4. * <p>@datetime 2019年8月8日 下午3:40:37</p >
  5. * <p>$Revision$</p >
  6. * <p>$Date$</p >
  7. * <p>$Id$</p >
  8. */
  9. package com.test;
  10.  
  11. import java.util.concurrent.atomic.AtomicInteger;
  12.  
  13. /**
  14.  * @author hong_liping
  15.  *
  16.  */
  17. public class AtomicAbaTest {
  18.      private static AtomicInteger ato=new AtomicInteger(1);
  19.     public static void main(String[] args) {
  20.         Thread mainT=new Thread(new Runnable() {
  21.  
  22.             @Override
  23.             public void run() {
  24.                 int a=ato.get();
  25.                 System.out.println(Thread.currentThread().getName()+"原子操作修改前数据"+a);
  26.                 try {
  27.                     Thread.sleep(200);
  28.                 } catch (InterruptedException e) {
  29.                     e.printStackTrace();
  30.                 }
  31.                 boolean successFlag=ato.compareAndSet(a, 2);
  32.                 if(successFlag){
  33.                     System.out.println(Thread.currentThread().getName()+"原子操作修改后数据"+ato.get());
  34.                 }
  35.  
  36.             }
  37.         },"mainT");
  38.  
  39.         Thread otherT=new Thread(new Runnable() {
  40.  
  41.             @Override
  42.             public void run() {
  43.                 int b=ato.incrementAndGet();//1+1
  44.                 System.out.println(Thread.currentThread().getName()+"原子操作自增后数据"+b);
  45.                  b=ato.decrementAndGet();//2-1
  46.                 System.out.println(Thread.currentThread().getName()+"原子操作自减后数据"+b);
  47.             }
  48.         },"OtherT");
  49.  
  50.         mainT.start();
  51.         otherT.start();
  52.     }
  53.  
  54. }
  55.  
  56. 测试结果：

OtherT原子操作自增后数据2
mainT原子操作修改前数据1
OtherT原子操作自减后数据1
mainT原子操作修改后数据2

  1.  

根据上面的操作，我们可以看到的是AtomicInteger的操作自增，自减，值的替换等。但是此处应当注意的是原子操作存在一个ABA问题，ABA问题的现象就是：mainT执行完成后的值2（替换的2），otherT在执行2-1的时候的2是自增（1+1）的结果。在这两个线程中用到的2不是同一个2，就相当于是一个漏洞，相当于说你从王健林账号中偷走了10个亿去投资，等你投资好了回本了，你再把这10个亿打回了王健林账号，这整个过程王建林没有发现，你的整个操作过程也没有记录，所以对于王健林来说他的钱没有丢失过，还是放在那里的。很明显要解决这个ABA问题最好的办法就是每一步操作都打个标记，相当于一个银行的流水，这样你偷钱，还钱的整个过程就有一个出，一个入，王健林看的时候就会发现我的总金没有变，但是操作记录显示我的钱曾经被人盗了然后又被人还回来了。这就需要用到AtomicStampeReference.

2、原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子的更新多个变 量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下三个类： AtomicReference：原子更新引用类型。 AtomicReferenceFieldUpdater：原子更新引用类型里的字段。 AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子的更 新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference(V initialRef, boolean initialMark)

接下来我们来看一下AtomicStampedReference的测试类：

  1. /**
  2. * <p>Title: AtomicStampedReference.java</p >
  3. * <p>Description: </p >
  4. * <p>@datetime 2019年8月9日 上午8:35:56</p >
  5. * <p>$Revision$</p >
  6. * <p>$Date$</p >
  7. * <p>$Id$</p >
  8. */
  9. package com.test;
  10.  
  11. import java.util.concurrent.atomic.AtomicInteger;
  12. import java.util.concurrent.atomic.AtomicStampedReference;
  13.  
  14. /**
  15.  * @author hong_liping
  16.  *
  17.  */
  18. public class AtomicStampedReferenceTest {
  19.  
  20.      private static AtomicStampedReference<Integer> asf=new AtomicStampedReference<Integer>(1, 0);
  21.     public static void main(String[] args) {
  22.         Thread mainT=new Thread(new Runnable() {
  23.  
  24.             @Override
  25.             public void run() {
  26.                 int stamp= asf.getStamp();
  27.                 System.out.println(Thread.currentThread().getName()+"原子操作修改前数据"+asf.getReference()+
  28.                         "_"+stamp);
  29.                 try {
  30.                     Thread.sleep(1000);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.                 //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败
  35.                 boolean successFlag=asf.compareAndSet(1, 2, stamp, stamp+1);
  36.                 if(successFlag){
  37.                     System.out.println(Thread.currentThread().getName()+"原子操作修改后数据"+asf.getReference()+
  38.                             "_"+stamp);
  39.                 }else{
  40.                     System.out.println(Thread.currentThread().getName()+"cas操作失败");
  41.                 }
  42.  
  43.             }
  44.         },"mainT");
  45.  
  46.         Thread otherT=new Thread(new Runnable() {
  47.  
  48.             @Override
  49.             public void run() {
  50.                 int stamp=asf.getStamp();
  51.                 asf.compareAndSet(1, 2, stamp, stamp+1);
  52.                 System.out.println(Thread.currentThread().getName()+"原子操作自增后数据"+asf.getReference()+
  53.                         "_"+asf.getReference());
  54.  
  55.                 asf.compareAndSet(2, 1, stamp, stamp+1);
  56.                 System.out.println(Thread.currentThread().getName()+"原子操作自减后数据"+asf.getReference()+
  57.                         "_"+stamp);;
  58.             }
  59.         },"OtherT");
  60.  
  61.         mainT.start();
  62.         otherT.start();
  63.     }
  64.  
  65. }
  66. //测试结果：
  67. mainT原子操作修改前数据2_0
  68. OtherT原子操作自增后数据2_2
  69. OtherT原子操作自减后数据2_0
  70. mainTcas操作失败
3、原子更新数组类
  通过原子的方式更新数组里的某个元素，Atomic包提供了以下三个类AtomicIntegerArray：原子更新整型数组里的元素。AtomicLongArray：原子更新长整型数组里的元素。 AtomicReferenceArray：原子更新引用类型数组里的元素。 omicIntegerArray类主要是提供原子的方式更新数组里的整型，其常用方法int addAndGet(int i, int delta)：以原子方式将输入值与数组中索加。boolean compareAndSet(int i, int expect, int update)：如果值，则以原子方式将数组位置i的元素设置成update值。

接下来我们来看一下AtomicIntegerArray的一个案例

  1. /**
  2. * <p>Title: AtomicArrayTest.java</p >
  3. * <p>Description: </p >
  4. * <p>@datetime 2019年8月10日 上午9:45:49</p >
  5. * <p>$Revision$</p >
  6. * <p>$Date$</p >
  7. * <p>$Id$</p >
  8. */
  9. package com.test;
  10.  
  11. import java.util.concurrent.atomic.AtomicIntegerArray;
  12.  
  13. import com.sun.org.apache.bcel.internal.generic.NEWARRAY;
  14.  
  15. /**
  16.  * @author hong_liping
  17.  *
  18.  */
  19. public class AtomicArrayTest {
  20.     static int[] array=new int[]{1,2,3};
  21.     static AtomicIntegerArray aia=new AtomicIntegerArray(array);
  22.     public static void main(String[] args) {
  23.         aia.getAndSet(1, 5);
  24.         System.out.println(aia.get(1));
  25.         System.out.println(array[1]);
  26.         if(aia.get(1)==array[1]){
  27.             System.out.println("数组中的值与原子数组中的相等");
  28.         }else{
  29.             System.out.println("数组中的值与原子数组中的不相等");
  30.         }
  31.     }
  32.  
  33. }结果：

5
2
数组中的值与原子数组中的不相等

  1.  

由以上的代码可以看出原子数组与我本身定义的数据同一个下标下的值是不一样的，为什么呢，我们看一下源码就会发现原子数据操作的并不是我定义的变量本身，而是先拷贝一份，然后操作的是拷贝的版本。

  1.  public AtomicIntegerArray(int[] array) {
  2.         // Visibility guaranteed by final field guarantees
  3.         this.array = array.clone();//初始化数组的时候拷贝
  4.     }
  1. public final int getAndSet(int i, int newValue) {
  2.         return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);
  3.     }
  1.  

在进行数据原子操作的时候使用的是魔术类Unsafe.

4、原子更新字段类

如果我们只需要某个类里的某个字段，那么就需要使用原子更新字段类，Atomic包提
供了以下三个类：
AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
AtomicLongFieldUpdater：原子更新长整型字段的更新器。
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值
与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子
更新时，可能出现的ABA问题。原子更新字段类都是抽象类，每次使用都时候必须使用静态方法newUpdater创建一个
更新器。原子更新类的字段的必须使用public volatile修饰符。

接下来我们再来看看AtomicIngerFieldUpdater

  1. /**
  2. * <p>Title: AtomicIntegerFieldUpdateTest.java</p >
  3. * <p>Description: </p >
  4. * <p>@datetime 2019年8月10日 上午10:02:22</p >
  5. * <p>$Revision$</p >
  6. * <p>$Date$</p >
  7. * <p>$Id$</p >
  8. */
  9. package com.test;
  10.  
  11. import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  12.  
  13. /**
  14.  * @author hong_liping
  15.  *
  16.  */
  17. public class AtomicIntegerFieldUpdateTest {
  18.     static AtomicIntegerFieldUpdater aifu=AtomicIntegerFieldUpdater.newUpdater(Person.class, "age");
  19.  
  20.     static class Person{
  21.         private String name;
  22.         public volatile int age;
  23.       public Person(String name,int age){
  24.           this.name=name;
  25.           this.age=age;
  26.       }
  27.       public  int getAge(){
  28.           return age;
  29.       }
  30.     }
  31.  
  32.     public static void main(String[] args) {
  33.             Person person=new Person("张三", 18);
  34.             System.out.println(aifu.getAndIncrement(person));
  35.             System.out.println(aifu.get(person));
  36.     }
  37.  
  38. }
  39.  
  40. 测试结果：

18
19

在age属性上加volatile是为了保证在多线程并发的情况下保证可见性。

Unsafe

Unsafe是位于sun.misc包下的一个类，主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。 Unsafe类为一单例实现，提供静态方法getUnsafe获取Unsafe实例，当且仅当调用getUnsafe方法的类为引导类加载器所加载时才合法，否则抛出SecurityException异常。

  1. @CallerSensitive
  2. /*      */   public static Unsafe getUnsafe()
  3. /*      */   {
  4. /*   88 */     Class localClass = Reflection.getCallerClass();
  5. /*   89 */     if (!VM.isSystemDomainLoader(localClass.getClassLoader()))// 仅在引导类加载器`BootstrapClassLoader加载时才合法
  6. /*   90 */       throw new SecurityException("Unsafe");
  7. /*   91 */     return theUnsafe;
  8. /*      */   }
  9. /*      */

Unsafe经常用到的就是CAS,内存屏障（禁止load,store重新排序），线程调度（线程挂起，恢复还有获取，释放锁）。

如何获取Unsafe,1、把调用Unsafe相关方法的类Demo所在jar包路径追加到默认的bootstrap路径中，使得A被引导类加载器加载 java -Xbootclasspath/Demo:${path} // 其中path为调用Unsafe相关方法的类所在jar包路径

2、通过反射获取单例对象theUnsafe

我们可以看一下下面的一个代码：

  1. public class UnsafeInstance {
  2.     public static Unsafe reflectGetUnsafe(){
  3.         Field field;
  4.         try {
  5.             field = Unsafe.class.getDeclaredField("theUnsafe");
  6.             field.setAccessible(true);
  7.             return (Unsafe) field.get(null);
  8.         } catch (Exception e) {
  9.             e.printStackTrace();
  10.         }
  11.         return null;
  12.     }
  13. }

接下来再来看一个利用Unsafe的代码：

  1. /**
  2. * <p>Title: AtomicUnsafeUpdaterTest.java</p >
  3. * <p>Description: </p >
  4. * <p>@datetime 2019年8月10日 上午10:57:23</p >
  5. * <p>$Revision$</p >
  6. * <p>$Date$</p >
  7. * <p>$Id$</p >
  8. */
  9. package com.test;
  10.  
  11. import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  12.  
  13. import sun.misc.Unsafe;
  14.  
  15. /**
  16.  * @author hong_liping
  17.  *
  18.  */
  19. public class AtomicUnsafeUpdaterTest {
  20.     private String name;
  21.     private volatile int age;
  22.     private static final Unsafe unsafe=UnsafeInstance.reflectGetUnsafe();
  23.     private static final long valueOffset;
  24.     static{
  25.         try {
  26.             valueOffset=unsafe.objectFieldOffset(AtomicUnsafeUpdaterTest.class.getDeclaredField("age"));//偏移量
  27.             System.out.println("initial valueOffset is "+valueOffset);
  28.         } catch (Exception e) {
  29.             throw new Error(e);
  30.         }
  31.     }
  32.    public void compareAndSwapAge(int old,int target){
  33.        unsafe.compareAndSwapInt(this, valueOffset, old, target);
  34.    }
  35.  
  36.    public AtomicUnsafeUpdaterTest(String name,int age){
  37.        this.name=name;
  38.        this.age=age;
  39.    }
  40.    public int getAge(){
  41.        return this.age;
  42.    }
  43.    public static void main(String[] args) {
  44.     AtomicUnsafeUpdaterTest test=new AtomicUnsafeUpdaterTest("美女",30);
  45.     test.compareAndSwapAge(30, 25);
  46.     System.out.println("年龄变换后的值为"+test.getAge());
  47. }
  48. }

1、CAS（unsafe的用法）的几个重要方法以及参数：

  1. /** * CAS
  2. * @param o 包含要修改field的对象
  3. * @param offset 对象中某field的偏移量
  4. * @param expected 期望值
  5. * @param update 更新值
  6.  * @return true | false */
  7. public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
  8. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
  9. public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

上述中的偏移量是什么呢，我们来看一下：AtomicUnsafeUpdaterTest的实现中，静态字段valueOffset即为字段value的内存偏移地址，valueOffset的值在AtomicInteger初始化时，在静态代码块中通过Unsafe的objectFieldOffset方法获取。在AtomicInteger中提供的线程安全方法中，通过字段valueOffset的值可以定位到AtomicUnsafeUpdaterTest对象中value的内存地址，从而可以根据CAS实现对value字段的原子操作。

下图为某个AtomicInteger对象自增操作前后的内存示意图，对象的基地址baseAddress=“0x110000”，通过baseAddress+valueOffset得到value的内存地valueAddress=“0x11000c”；然后通过CAS进行原子性的更新操作，成功则返回，否则继续重试，直到更新成功为止。

2、unsafe线程调度

包括线程挂起、恢复、锁机制等方法。

//取消阻塞线程
public native void unpark(Object thread);
//阻塞线程
public native void park(boolean isAbsolute, long time);
//获得对象锁（可重入锁）
@Deprecated
public native void monitorEnter(Object o);
//释放对象锁
@Deprecated
public native void monitorExit(Object o);
//尝试获取对象锁
@Deprecated
public native boolean tryMonitorEnter(Object o);
方法park、unpark即可实现线程的挂起与恢复，将一个线程进行挂起是通过park方法实现的，调用park方法后，线程将一直阻塞直到超时或者中断等条件出现；unpark可以终止一个挂起的线程，使其恢复正常。在使用park和unpark的时候是可以颠倒的，先使用unpark,相当于取得一张票，在使用park的时候相当于使用这张票。
典型应用
Java锁和同步器框架的核心类AbstractQueuedSynchronizer，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的，而LockSupport的park、unpark方法实际是调用Unsafe的park、unpark方式来实现。 
  1. public class ThreadParkerTest {
  2.  
  3.     public static void main(String[] args) {
  4.  
  5.         /*Thread t = new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 System.out.println("thread - is running----");
  9.                 LockSupport.park();//阻塞当前线程
  10.                 System.out.println("thread is over-----");
  11.             }
  12.         });
  13.  
  14.         t.start();
  15.  
  16.         try {
  17.             Thread.sleep(1000);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         LockSupport.unpark(t);//唤醒指定的线程*/
  22.  
  23.         //拿出票据使用
  24.         LockSupport.park();
  25.  
  26.         System.out.println("main thread is over");
  27.         //相当于先往池子里放了一张票据
  28.         LockSupport.unpark(Thread.currentThread());//Pthread_mutex
  29.  
  30.         System.out.println("im running step 1");
  31.  
  32.     }
  33.  
  34. }
  1. public class ObjectMonitorTest {
  2.     static Object object = new Object();
  3.  
  4. /*    public void method1(){
  5.         unsafe.monitorEnter(object);
  6.     }
  7.  
  8.     public void method2(){
  9.         unsafe.monitorExit(object);
  10.     }*/
  11.  
  12.     public static void main(String[] args) {
  13.  
  14.         /*synchronized (object){
  15.         }*/
  16.         Unsafe unsafe = UnsafeInstance.reflectGetUnsafe();
  17.  
  18.         unsafe.monitorEnter(object);//获取锁
  19.         //业务逻辑写在此处之间
  20.         unsafe.monitorExit(object);//锁释放
  21.  
  22.     }
  1.  
  1.  

3、内存屏障

在Java 8中引入，用于定义内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的
所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。
//内存屏障，禁止load操作重排序。屏障前的load操作不能被重排序到屏障后，屏障后的load操作不能被重排序到屏障前
public native void loadFence();
//内存屏障，禁止store操作重排序。屏障前的store操作不能被重排序到屏障后，屏障后的store操作不能被重排序到屏障前
public native void storeFence();
//内存屏障，禁止load、store操作重排序
public native void fullFence();
典型应用
在Java 8中引入了一种锁的新机制——StampedLock，它可以看成是读写锁的一个改进版本。StampedLock提供了一种乐观读锁的实现，这种乐观读锁类似于无锁的操作，完
全不会阻塞写线程获取写锁，从而缓解读多写少时写线程“饥饿”现象。由于StampedLock提供的乐观读锁不阻塞写线程获取读锁，当线程共享变量从主内存load到线程工作内存时，会存在数据不一致问题，所以当使用StampedLock的乐观读锁时，需要遵从如下图用例中使用的模式来确保数据的一致性。

  1. public class FenceTest {
  2.  
  3.     public static void main(String[] args) {
  4.  
  5.         UnsafeInstance.reflectGetUnsafe().loadFence();//读屏障
  6.  
  7.         UnsafeInstance.reflectGetUnsafe().storeFence();//写屏障
  8.  
  9.         UnsafeInstance.reflectGetUnsafe().fullFence();//读写屏障
  10.  
  11.     }
  12. }

并发编程之原子Atomic&Unsafe的更多相关文章

  1. 并发编程之原子操作Atomic&Unsafe

    原子操作:不能被分割(中断)的一个或一系列操作叫原子操作. 原子操作Atomic主要有12个类,4种类型的原子更新方式,原子更新基本类型,原子更新数组,原子更新字段,原子更新引用.Atomic包中的类 ...

  2. 并发编程-JUC之Atomic

    概述: 早期的JDK版本中,如果要并发的对Integer.Long.Double之类的Java原始类型或引用类型进行操作,一般都需要通过锁来控制并发,以防止数据不一致.JUC-Atomic原子类位于j ...

  3. C++11并发编程：原子操作atomic

    一:概述 项目中经常用遇到多线程操作共享数据问题,常用的处理方式是对共享数据进行加锁,如果多线程操作共享变量也同样采用这种方式. 为什么要对共享变量加锁或使用原子操作?如两个线程操作同一变量过程中,一 ...

  4. java并发编程学习: 原子变量（CAS）

    先上一段代码: package test; public class Program { public static int i = 0; private static class Next exte ...

  5. Java多线程并发编程之原子变量与非阻塞同步机制

    1.非阻塞算法 非阻塞算法属于并发算法,它们可以安全地派生它们的线程,不通过锁定派生,而是通过低级的原子性的硬件原生形式 -- 例如比较和交换.非阻塞算法的设计与实现极为困难,但是它们能够提供更好的吞 ...

  6. Java并发编程之原子变量

    原子变量最主要的一个特点就是所有的操作都是原子的,synchronized关键字也可以做到对变量的原子操作.只是synchronized的成本相对较高,需要获取锁对象,释放锁对象,如果不能获取到锁,还 ...

  7. [转]JAVA并发编程学习笔记之Unsafe类

    1.通过Unsafe类可以分配内存,可以释放内存:类中提供的3个本地方法allocateMemory.reallocateMemory.freeMemory分别用于分配内存,扩充内存和释放内存,与C语 ...

  8. 并发编程 20—— AbstractQueuedSynchronizer 深入分析

    Java并发编程实践 目录 并发编程 01—— ThreadLocal 并发编程 02—— ConcurrentHashMap 并发编程 03—— 阻塞队列和生产者-消费者模式 并发编程 04—— 闭 ...

  9. 并发编程 05—— Callable和Future

    Java并发编程实践 目录 并发编程 01—— ThreadLocal 并发编程 02—— ConcurrentHashMap 并发编程 03—— 阻塞队列和生产者-消费者模式 并发编程 04—— 闭 ...

随机推荐

  1. div 可滚动但不显示滚动条

    (原) 首先有3个div, 第1个,固定大小是200*200(单位为px,下同) 第2个,不固定大小,其大小要用第3个div把个撑开,但是这个div必需要有滚动条, 第3个,固定大小与第1个div保持 ...

  2. python 示例代码4

    示例:用户输入和格式化输出(用户输入demo1)

  3. Rails6新特性actionable Error

    视频:https://gorails.com/episodes/actionable-errors-in-rails-6?autoplay=1 这篇视频介绍了Rails6的一个新功能: actiona ...

  4. p2456二进制方程 题解

    题面描述:可以跳过 一个形如: X1X2…Xn=Y1Y2..Ym 的等式称为二进制方程. 在二进制方程的两边:Xi和Yj (1<=i<=n:1<=j<=m)是二进制数字(0.1 ...

  5. 数据管理必看！Kendo UI for jQuery过滤器状态保持

    Kendo UI for jQuery最新试用版下载 Kendo UI目前最新提供Kendo UI for jQuery.Kendo UI for Angular.Kendo UI Support f ...

  6. 浮动float和清除clear

    一.浮动(float) float简介 取值:left,right,none,inherit,默认none(不浮动) 可应用与所有元素 没有继承性 不在正常流中,但会影响布局.因为一个元素浮动时,其他 ...

  7. 【Java Web】简易商品信息管理系统——首个Web项目

    正文之前 在学习了一段时间的Java Web的内容之后,当然需要有个项目来练练手,我相信大多数人的首选项目都是信息管理系统吧,所以我选择了商品信息管理系统 目前项目源码已全部上传至GitHub,欢迎大 ...

  8. 数位dp入门(内容一样,新版格式)

    顾名思义,数位dp,是一种用来计数的dp,就是把一个数字拆成一个一个数位去统计 如果现在给你一道题,需要你求在区间[l,r]内满足条件的解的个数,我们很容易想到去暴力枚举,但要是数据范围太大这种办法就 ...

  9. 灰度图像--图像分割 Robert算子

    学习DIP第43天 转载请标明本文出处:http://blog.csdn.net/tonyshengtan,欢迎大家转载,发现博客被某些论坛转载后,图像无法正常显示,无法正常表达本人观点,对此表示很不 ...

  10. css引入第三方字体

    上面图片时将字体文件放入到fonts文件夹内, 里面有一个fonts.css文件,将字体文件声明好, 然后像下面图片一样,在另外一个css内@import引入,(当然,也可以直接将声明和引用放在一个c ...