Java_多线程_原子性操作

最新推荐文章于 2024-09-22 00:47:19 发布
最新推荐文章于 2024-09-22 00:47:19 发布
阅读量861 收藏 1
点赞数
分类专栏： Java 
何谓原子性操作，即为最小的操作单元，比如i=1，就是一个原子性操作，这个过程只涉及一个赋值操作。又如i++就不是一个原子操作，它相当于语句i=i+1；这里包括读取i，i+1，结果写入内存三个操作单元。因此如果操作不符合原子性操作，那么整个语句的执行就会出现混乱，导致出现错误的结果，从而导致线程安全问题。

因此，在多线程中需要保证线程安全问题，就应该保证操作的原子性，那么如何保证操作的原子性呢？

其一当然是加锁，这可以保证线程的原子性，比如使用synchronized代码块保证线程的同步，从而保证多线程的原子性。但是加锁的话，就会使开销比较大。

另外，可以使用J.U.C下的atomic来实现原子操作。接下来我们就通过对比来说明atomic实现原子操作的功能。

一般情况下如果我们想避免原子性问题的时都会选择加锁，但是我们都知道加锁和解锁是有消耗的。并且只要有加锁、解锁就会伴随着线程阻塞、线程的唤醒，这样线程的切换也是消耗性能的。

从JDK1.5起就提供了原子类，能无锁的避免原子性问题，所以在简单的情况下，而且是只有就竞争一个共享变量的情况下，可以使用Java原子类，如果是多个共享变量的话基本上只能加锁了，原子类就不太好使了！

Java原子类可以分为五大类：原子更新基本类型、原子更新数组、原子更新引用类型、原子更新属性(类的字段)、原子累加器。

它们是怎么做到没加锁实现原子性的呢？没什么大秘密就是硬件的支持！我们知道CPU指令肯定是原子性的，为了解决并发的问题CPU提供了一条指令——CAS(compare and swap 即比较并交换)。

CAS 指令包含 3 个参数：共享变量的内存地址 A、用于比较的值 B 和共享变量的新值 C。只有当内存中地址A的值等于B，才能把地址A的值变成C。

也就是只有预期值B等于内存地址A中的值时，表明共享变量没有被其他线程修改过，所以才允许更新新值，这样就保证了原子性！

CAS还会有ABA问题，就是当你比较的时候，可能你的值被一个线程改了之后，另一个线程又改了回来，然后你比较的时候发现和预期值一样，其实是被改过的。就类似你走在路上，你手机放口袋里，小偷偷走了你的手机，但是一抬头看到了头上的监控，又默默的放回你的口袋。你根本不知道发生了这件事，然后悠然的拿起手机，刷了波朋友圈，又默默的塞进口袋。。。

大部分情况下不需要关心这个，例如基本类型等，但是原子更新引用类型，因为可能比较的时候线程但是里面的某个属性已经变了。可以添加一个版本号来避免这个问题。

通常利用CAS来解决并发问题都通过自旋手段，这里的自旋的其实循环尝试，再说白一点就是while循环。举个例子来看一下AtomicInteger源码，声明了 private volatile int value; 通过volatile 关键字保证可见性。

原子类都是调用sun.misc.Unsafe来的实现的，就比如上面的代码就是调用unsafe.getAndAddInt()。

do while就是自旋操作了，compareAndSwapInt是native方法。

所有的原子类实现基本上都是这个思路！讲白了就是调用硬件提供CAS这种操作，Java并发包帮我们封装了一下，使得我们更容易的调用！

1.非原子操作
首先，了解一下若不保证原子操作会出现什么样的情况。代码如下：

package concurrent;
import java.util.concurrent.*;
public class GeneralTest {
private static final ExecutorService es=Executors.newFixedThreadPool(10);
private static int count=0;
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=0;i<20;i++)
{
Thread t1=new Thread(){
public void run(){

				count+=1;
			}
		};
		es.execute(t1);
	}
	for(int i=0;i<5;i++)
		System.out.println("累加20次，得到结果是："+count);

}

}
以上就是创建20个线程进行对count这个类变量自增一次，预期的值应该是20，但是运行上述程序出现如下结果：

累加20次，得到结果是：16
累加20次，得到结果是：19
累加20次，得到结果是：19
累加20次，得到结果是：19
累加20次，得到结果是：19
从以上结果可以看出，输出五次的结果都是没有达到20，可能出现的问题便是count+=1包含了三个操作，可能这个线程读取count的时候，上一个线程还没把更新的count值写入内存，这就是因无法保证操作的原子性而导致的线程安全问题。

2.通过synchronized加锁
synchronized称为互斥锁，它的工作原理就是一旦一个线程抢占了得到锁，其它线程便进入等待状态，只有当该线程释放锁，其它线程才有获取锁的机会。因此使用synchronized对count加锁，那么实现的操作便是原子性操作，因为只有当一个线程完成所有操作，然后释放锁，其它线程才会抢占锁。以下还是自增问题，当一个线程在实现++count时，只有当该线程将数据存入内存，释放锁之后，其它内存才会获取锁，读取数据，因此不会出现干涉问题，从而避免线程安全问题。

package concurrent;
import java.util.concurrent.*;
public class GeneralTest {
private static final ExecutorService es=Executors.newFixedThreadPool(20);
private static Integer count=0;
public static void main(String[] args) {
// TODO Auto-generated method stub
long start=System.currentTimeMillis();
for(int i=0;i<1000;i++)
{
Thread t1=new Thread(){
public void run(){

				//count+=1;
				synchronized(count)
				{
					System.out.println(Thread.currentThread().getName()+"实现了自增一次，结果为："+(++count));
				}
			}
		};
		
		es.execute(t1);
	}
	try
	{
		Thread.sleep(5000);
	}
	catch(InterruptedException e)
	{
		e.printStackTrace();
	}
	System.out.println("计算过程的耗时为："+(System.currentTimeMillis()-start-5000));
	System.out.println("累加1000次，得到结果"+count);
}

}
运行以上程序，得到如下结果，由于累加1000次太多，所以不把每次加的结果显示出来，只显示一部分过程以及最终的结果。

pool-1-thread-8实现了自增一次，结果为：999
pool-1-thread-8实现了自增一次，结果为：1000
pool-1-thread-2实现了自增一次，结果为：679
pool-1-thread-14实现了自增一次，结果为：678
pool-1-thread-3实现了自增一次，结果为：677
pool-1-thread-1实现了自增一次，结果为：675
pool-1-thread-19实现了自增一次，结果为：674
pool-1-thread-13实现了自增一次，结果为：673
pool-1-thread-10实现了自增一次，结果为：882
pool-1-thread-7实现了自增一次，结果为：881
pool-1-thread-17实现了自增一次，结果为：715
pool-1-thread-9实现了自增一次，结果为：714
pool-1-thread-5实现了自增一次，结果为：713
pool-1-thread-11实现了自增一次，结果为：712
pool-1-thread-20实现了自增一次，结果为：706
pool-1-thread-18实现了自增一次，结果为：698
pool-1-thread-4实现了自增一次，结果为：697
pool-1-thread-16实现了自增一次，结果为：696
pool-1-thread-15实现了自增一次，结果为：695
pool-1-thread-6实现了自增一次，结果为：694
pool-1-thread-12实现了自增一次，结果为：693
计算过程的耗时为：13
累加1000次，得到结果1000
从上面可以看出，结果和预期一样，并且计算过程花费了13ms。

3.atomic实现
atomic系列的类在是J.U.C包下的一系列类。它主要包括四类：基本类型，数组类型，属性原子修改器类型，引用类型。

基本类型的类主要包括AtomicInteger、AtomicLong、AtomicBoolean等；数组类型主要包括AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray；属性原子修改器类型主要包括AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater ；引用类型主要包括AtomicReference、AtomicStampedRerence、AtomicMarkableReference。

1.基本类型的实现：

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicTest {
private static final AtomicInteger at=new AtomicInteger();
private static final ExecutorService es=Executors.newFixedThreadPool(20);
public static void main(String[] args) {
// TODO Auto-generated method stub
long start=System.currentTimeMillis();
for(int i=0;i<1000;i++)
{
Thread t1=new Thread() {
public void run()
{
System.out.println(Thread.currentThread().getName()+“实现了一次自增原子操作，结果为：”+at.incrementAndGet());
}
};
es.execute(t1);
}
try
{
Thread.sleep(5000);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println(“计算过程的耗时为：”+(System.currentTimeMillis()-start-5000));
System.out.println(“累加1000次，得到结果”+at);

}

}
运行结果如下：

pool-1-thread-13实现了一次自增原子操作，结果为：984
pool-1-thread-8实现了一次自增原子操作，结果为：983
pool-1-thread-14实现了一次自增原子操作，结果为：982
pool-1-thread-20实现了一次自增原子操作，结果为：981
pool-1-thread-10实现了一次自增原子操作，结果为：980
pool-1-thread-12实现了一次自增原子操作，结果为：979
pool-1-thread-3实现了一次自增原子操作，结果为：978
pool-1-thread-7实现了一次自增原子操作，结果为：977
pool-1-thread-4实现了一次自增原子操作，结果为：976
pool-1-thread-18实现了一次自增原子操作，结果为：1000
pool-1-thread-9实现了一次自增原子操作，结果为：999
pool-1-thread-17实现了一次自增原子操作，结果为：998
pool-1-thread-6实现了一次自增原子操作，结果为：997
pool-1-thread-5实现了一次自增原子操作，结果为：996
pool-1-thread-2实现了一次自增原子操作，结果为：995
计算过程的耗时为：9
累加1000次，得到结果1000
由上面可知使用基本类型的原子操作类进行数字的自增，不仅可以保证操作操作的原子性，而且相对来说花费的时间代价比使用synchronized加锁的时间代价要小。

2.数组类型

    以下以AtomicIntegerArray为例通过对一个数组内的每个元素进行自增计算，从而来介绍数组类型的原子类的运用。

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicIntegerArray;
public class AtomicTest {
private static final AtomicIntegerArray at=new AtomicIntegerArray(new int[5]);
private static final ExecutorService es=Executors.newFixedThreadPool(20);
public static void main(String[] args) {
// TODO Auto-generated method stub
long start=System.currentTimeMillis();
for(int i=0;i<1000;i++)
{
Thread t1=new Thread() {
public void run()
{
for(int i=0;i<5;i++)
System.out.println(Thread.currentThread().getName()+“实现了对第”+(i+1)+“个元素一次自增原子操作，结果为：”+at.incrementAndGet(i));
}
};
es.execute(t1);
}
try
{
Thread.sleep(5000);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println(“计算过程的耗时为：”+(System.currentTimeMillis()-start-5000));
for(int i=0;i<5;i++)
System.out.println(“第”+(i+1)+“个元素累加1000次，得到结果”+at.get(i));

}

}
运行程序结果如下，其中运算过程部分给出：

pool-1-thread-3实现了对第5个元素一次自增原子操作，结果为：980
pool-1-thread-20实现了对第1个元素一次自增原子操作，结果为：989
pool-1-thread-20实现了对第2个元素一次自增原子操作，结果为：1000
pool-1-thread-20实现了对第3个元素一次自增原子操作，结果为：1000
pool-1-thread-20实现了对第4个元素一次自增原子操作，结果为：1000
pool-1-thread-20实现了对第5个元素一次自增原子操作，结果为：1000
pool-1-thread-15实现了对第5个元素一次自增原子操作，结果为：998
计算过程的耗时为：9
第1个元素累加1000次，得到结果1000
第2个元素累加1000次，得到结果1000
第3个元素累加1000次，得到结果1000
第4个元素累加1000次，得到结果1000
第5个元素累加1000次，得到结果1000
从结果可以看出，数组类型的原子类的使用，可以保证每个元素的自增等操作都满足原子性。

3.属性原子修改器

    以AtomicIntegerFieldUpdater类为例，该类有一个静态方法newUpdater(Class<U> tclass,String fieldName),则这个表示为tclass类的fieldName属性创建一个属性原子修改器，如果需要修改该属性，则只需要调用原子修改器的方法，比如addAndGet(tclass obj,int delta)：该方法表示将该修改器对应的属性增加delta。以下通过代码来了解属性原子修改器的作用。

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
class Count{
public volatile int number;
}
public class AtomicTest {
private static final AtomicIntegerFieldUpdater aifu=AtomicIntegerFieldUpdater.newUpdater(Count.class, “number”);
private static final ExecutorService es=Executors.newFixedThreadPool(20);
public static void main(String[] args) {
// TODO Auto-generated method stub
final Count count=new Count();
long start=System.currentTimeMillis();
for(int i=0;i<1000;i++)
{
Thread t1=new Thread() {
public void run()
{

				System.out.println(Thread.currentThread().getName()+"实现了一次自增原子操作，结果为："+aifu.addAndGet(count, 1));
			}
		};
		es.execute(t1);
	}
	try
	{
		Thread.sleep(5000);
	}
	catch(InterruptedException e)
	{
		e.printStackTrace();
	}
	System.out.println("计算过程的耗时为："+(System.currentTimeMillis()-start-5000));
	for(int i=0;i<5;i++)
		System.out.println("第"+(i+1)+"个元素累加1000次，得到结果"+count.number);
	

}

}
运行以上程序，得到如下结果：

pool-1-thread-17实现了一次自增原子操作，结果为：993
pool-1-thread-5实现了一次自增原子操作，结果为：992
pool-1-thread-19实现了一次自增原子操作，结果为：991
pool-1-thread-3实现了一次自增原子操作，结果为：990
pool-1-thread-15实现了一次自增原子操作，结果为：989
pool-1-thread-20实现了一次自增原子操作，结果为：988
pool-1-thread-18实现了一次自增原子操作，结果为：987
pool-1-thread-6实现了一次自增原子操作，结果为：986
pool-1-thread-7实现了一次自增原子操作，结果为：985
pool-1-thread-9实现了一次自增原子操作，结果为：984
计算过程的耗时为：10
第1个元素累加1000次，得到结果1000
第2个元素累加1000次，得到结果1000
第3个元素累加1000次，得到结果1000
第4个元素累加1000次，得到结果1000
第5个元素累加1000次，得到结果1000
从上面结果可以看出，属性原子修改器的使用也能达到原子性操作的目的。

4.引用类型

    以AtomicReference类为例，通过AtomicReference<Count> ar=new AtomicReference<>()；ar可以调用set()方法设置初始值，调用compareAndSet(expect，update):这个方法就是将存在ar中的值与expect值作比较，如果两者相等，则更新该值为update；代码如下：

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
class Count{
public int count;
public Count(int count)
{
this.count=count;
}
public String toString()
{
return “这个对象的位置是：”+count;
}
}
public class AtomicTest {
private static final AtomicReference ar=new AtomicReference();

public static void main(String[] args) {
	// TODO Auto-generated method stub
	Count count=new Count(1001);
	long start=System.currentTimeMillis();
	ar.set(count);
	System.out.println("你好，"+ar.get());
	Count count1=new Count(1002);
	ar.compareAndSet(count, count1);//内存值与count是一样的，所以值更新为count1
	System.out.println("我发生了改变："+ar.get());
	Count count2=new Count(1003);
	ar.compareAndSet(count, count2);//此时内存智为count1，与count不一致，所以无法更新，因此内存值依然为count1
	System.out.println("我发生了改变："+ar.get());

}

}
运行程序，结果如下：

你好，这个对象的位置是：1001
我发生了改变：这个对象的位置是：1002
我发生了改变：这个对象的位置是：1002

扩展阅读

原子更新基本类型

相关实现类：AtomicBoolean、AtomicInteger、AtomicLong。主要就是用来基本类型的操作

原子更新数组类型

相关实现类：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray。可以原子化地更新数组里面的每一个元素，和原子更新基本类型差别就是基本上方法都多了个数组的下标。

原子更新引用类型

相关实现类：AtomicReference、AtomicStampedReference 、AtomicMarkableReference。这个就要重点关注ABA，但是Java已经关注到了所以AtomicStampedReference 和 AtomicMarkableReference 就能避免ABA问题了，就是用了版本号！

原子更新字段类型

相关实现类：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

它们可以原子化地更新对象的属性，注意更新类的字段(属性)必须使用public volatile修饰符，这样才能保证可见性。

原子累加器

相关实现类：LongAccumulator、LongAdder、DoubleAccumulator、DoubleAdder。这几个类只能用来进行累加操作，现对于原子更新基本类型它们的性能更好些，所以如果只有累加操作可以用这几个类！

Bobyte
关注
专栏目录
Java多线程：线程操作的原子性问题
流楚丶格念的博客
07-16 1715
概述 : 原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。例如一个送冰淇淋的案例：开启100条线程，每个线程送100个冰淇淋。代码实现 : 运行结果如下： 从结果看出，最后不是10000个冰淇淋，有些count++操作被“打断”了。代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断，并且说明 volatile关键字不能保证原子性解决方案 : 我们可以给coun
Java-多线程中的原子性问题
浮华′的博客
12-12 485
文章目录一、volatile关键字二、原子性三、Atomic包1.Atomic包概述2.AtomicInteger的常用方法3.AtomicInteger内存解析四、悲观锁和乐观锁 一、volatile关键字 当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题 堆内存是唯一的，每一个线程都有自己的线程栈。 每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。 在线程中，每一次使用是从变量的副本中获取的。 Volatile关键字 : 强制
java线程:Atomic(原子的)
点点滴滴的足迹，幻化成漫天的云彩
03-29 511
    一、何谓Atomic？  Atomic一词跟原子有点关系，后者曾被人认为是最小物质的单位。计算机中的Atomic是指不能分割成若干部分的意思。如果一段代码被认为是Atomic，则表示这段代码在执行过程中，是不能被中断的。通常来说，原子指令由硬件提供，供软件来实现原子方法（某个线程进入该方法后，就不会被中断，直到其执行完成）    在x86 平台上，CPU提供了在指令执行期间对总线...
Java多线程——如何保证原子性_java怎么保证原子性
最新发布
2401_87373733的博客
09-22 1028
线程过多会带来额外的开销，频繁创建和销毁大量线程需要占用系统资源，消耗大量时间。其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。
多线程
weixin_47216239的博客
07-13 231
方式一：同步代码块 package ManyThread1; public class MyThread extends Thread{ private static int ticketCount = 100; //此时的成员变量要用static，因为要不同对象调用一份数据 @Override public void run(){ while (true){ synchronized(MyThread.class){ //Synchr
Java多线程之原子性
NEU_PRO_YZ的博客
05-18 2007
友情提示：作为一个java小白最近在看java多线程知识，东西还是比较多，推荐大家去看《Java多线程编程指南》，怕自己忘了，所以决定码些字。 开始之前，建议大家一定要系统地学习一下操作系统，并且不能光看网上碎片化的知识点，所以一点一点来吧。 我准备先回顾一下非常基础而且重要的知识点，先从三个特性下手，原子性，可见性，有序性。每一点的内容都很多，一点一点来，先介绍原子性。 原子性： 定...
Java并发编程 - 多线程原子性、一致性与有序性
逍遥Sean的博客
10-23 1028
多线程原子性、一致性和有序性是指在多线程编程中，保证数据正确性和程序执行顺序的三个重要概念。 多线程原子性、一致性和有序性是指在多线程编程中，保证数据正确性和程序执行顺序的三个重要概念。 > > 1. 原子性：原子操作是指不可中断的一个操作，要么全部执行成功，要么全部执行失败，中间不会被其他线程干扰。多线程环境下，如果多个线程同时更新一个共享变量，就可能出现问题。原子性的解决方案包括使用原子类、锁和同步机制等。 > 2. 一致性：一致性是指对于多个线程之间共享的数据，操作后数据的状态保持一致。在多线程环境
JAVA-JavaThreadProgramming-Sams.zip_JAVA 设计_java 多线程_java 线程_多线程
09-14
Java多线程允许程序同时执行多个任务，这极大地提高了程序的效率和响应性。在Java中，线程可以分为两类：用户线程和守护线程。用户线程是应用程序的主要执行单元，而守护线程则服务于用户线程，如垃圾收集器就是典型...
Java多线程编程核心技术_完整版_java_
09-30
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过继承Thread类或实现Runnable接口来实现。本教程《Java多线程编程核心技术》将...
java多线程中的原子操作
03-21
在Java多线程编程中，原子操作是一种非常关键的概念，它涉及到并发控制和线程安全。原子操作是指在不被其他线程中断的情况下，能够完整执行的一个或一系列操作。这样的操作在多线程环境中可以保证数据的一致性和完整...
java多线程_java多线程下变量共享_
09-30
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提升系统效率。在多线程环境中，变量共享是一个常见的需求，但也是引发问题的关键点。本篇文章将深入探讨Java多线程下变量共享的问题以及解决...
java多线程 原子 性_Java多线程 – 原子性问题
weixin_39602976的博客
02-13 396
并发编程三大核心问题并发编程：原子性问题 是指线程切换带来的原子性问题。由于IO太慢，早期的操作系统就发明了多进程，即便在单核的CPU上我们也可以一边听着歌，一边写Bug，这个就是多进程的功劳。操作系统允许某个进程执行一小段时间，例如50毫秒，过了50毫秒操作系统就会重新选择一个进程来执行(我们称为“任务切换”)，这个50毫秒称为“时间片”。在一个时间片内，如果一个进程进行一个IO操作，例如读个文...
多线程原子性
温良
07-14 349
目录 原子性 AtomicInteger内存解析 自旋锁+CAS算法 原子性 所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。 public class AtomDemo { public static void main(String[] args) { MyAtomThread atom = new MyAtomThread(); .
java多线程之原子性
qq_34058450的博客
04-04 530
1.1原子性 假定有两个线程A和B，他们要操作一个变量C，当A操作C的时候B不操作或者说是无法操作B，那么就说名 操作C的操作是原子的，也是线程安全的 例子：UnSafe private static int anInt = 1; public static void main(String[] args) { new Thread(()->{anInt++;})....
JAVA原子性操作
weixin_34348111的博客
06-02 111
为什么80%的码农都做不了架构师？>>> ...
java多线程实战学习2-原子性
destiny_m的专栏
03-09 219
# 原子性 原子性，这个应该是广义的名词，在数据库中用的更常见，指的是一个操作的执行是完全执行完的，不能被打断，要么全部执行，要不完全不执行，不能执行一半。 这个也是java多线程的基础，例如i++这个操作，本身不是原子性的，它包含三个操作 寄存器读取i的内存中的值 寄存器中执行i+1操作 寄存器将新值赋到i变量的内存中 另外，java基本类型中long和double的写也不是原子性的，分两次...
java多线程原子性_java多线程的原子性
weixin_35890888的博客
02-16 282
class Count {public int num;public synchronized void increment() {num++;}public int get() {return num;}}public class ThreadDemo1 {public static void main(String[] args) {final Count count = new Count(...
Java并发编程（十三）Java 中的原子性操作
逆流者的博客
01-23 1796
此文为读书笔记，欢迎评论，谈论问题，共同进步！ 原子性操作，是指执行一系列操作时，这些操作要么全部执行，要么全部不执行，不存在只执行其中一部分的情况。在设计计数器时一般都先读取当前值，然后+1，再更新。这个过程是读—改一写的过程，如果不能保证这个过程是原子性的，那么就会出现线程安全问题。 Java 中的 CAS操作 CAS（Compare and Swap），其是 JDK提供的非阻塞原子性操作，它通过硬件保证了比较一更新操作的原子性。JDK里面的Unsafe类提供了一系列的 compareAndSwap*
Java多线程 原子性的介绍
Java持续实践
09-06 478
文章目录原子性的介绍Java中的原子操作 原子性的介绍 原子性是指: 一系列的操作, 要么全部执行成功, 要么全部执行失败, 不会出现执行一半的情况, 这一系列操作是不可分割的. 典型的i++操作就不是原子性的. 例如下图中i++是要先读取i, 再加一, 再给赋值回去, 是三步. 用synchronized锁把这三个步骤锁起来, 才能实现原子性. Java中的原子操作 除了long和double 之外的基本数据类型(int byte boolean short char float)的赋值操作 所有
Java多线程安全基础：原子性、可见性和有序性详解
Java多线程安全性基础介绍...总结来说，Java多线程安全性涉及原子性、可见性和有序性的保证，以及对共享资源的管理和同步策略。理解并应用这些概念和原则有助于编写健壮的并发代码，确保在多线程环境中程序的正确执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值