Java 线程安全之原子性

Java 线程安全之原子性

原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可被打乱，也不可以被切割而执行其中的一部分(不可中断)。将整个操作视为一个整体是原子性的核心特征。

首先看下面这样一段代码，两个线程都对count变量进行自加操作10000次

public class ThreadSecurityDemo {

private long count = 0;

public void test() throws InterruptedException {

for (int i = 2; i > 0; i--) {

new Thread(()->{

for (int j = 0; j < 10000; j++) {

count++;

}

}).start();

}

Thread.sleep(1000);

System.out.println(count);

}

public static void main(String[] args) throws InterruptedException {

ThreadSecurityDemo demo = new ThreadSecurityDemo();

demo.test();

}

}

运行结果如下：

按理来说count的值应该是20000，但实际上却不是，这就出现了线程安全问题，为了解决这个问题，我们可以使用同步代码块。

test方法修改如下：

public void test() throws InterruptedException {

for (int i = 2; i > 0; i--) {

new Thread(()->{

for (int j = 0; j < 10000; j++) {

synchronized (this)

{

count++;

}

}

}).start();

}

Thread.sleep(1000);

System.out.println(count);

}

实际上，java的J.U.C包内为我们提供了原子操作的封装类：

AtomicBoolean: 原子更新布尔类型

AtomicInteger：原子更新整型

AtomicLong：原子更新长整型

等等…

使用很简单，我们使用AtomicLong来解决上面的问题

import java.util.concurrent.atomic.AtomicLong;

public class ThreadSecurityDemo {

private AtomicLong atoacount= new AtomicLong(0L);

public void test() throws InterruptedException {

for (int i = 2; i > 0; i--) {

new Thread(()->{

for (int j = 0; j < 10000; j++) {//自增

atoacount.incrementAndGet();

}

}).start();

}

Thread.sleep(1000);

System.out.println(atoacount);

}

public static void main(String[] args) throws InterruptedException {

ThreadSecurityDemo demo = new ThreadSecurityDemo();

demo.test();

}

}

虽然效果一样，但是这种方法的执行效率比同步代码块高。

jdk1.8后加入了LongAdder，DoubleAdder的计数器，在高并发情况下性能更好，同样能够解决这个问题。

LongAdder会将一个数据分成多个操作单元，不同的线程更新不同的单元，只要需要汇总的时候才计算所有单元的操作。

import java.util.concurrent.atomic.LongAdder;

public class ThreadSecurityDemo {

private LongAdder lacount = new LongAdder();

public void test() throws InterruptedException {

for (int i = 2; i > 0; i--) {

new Thread(()->{

for (int j = 0; j < 10000; j++) {

lacount.increment();

}

}).start();

}

Thread.sleep(1000);

System.out.println(lacount.sum());

}

public static void main(String[] args) throws InterruptedException {

ThreadSecurityDemo demo = new ThreadSecurityDemo();

demo.test();

}

}

下面我们通过三者在两秒钟内执行的次数来比较执行效率

import java.util.concurrent.atomic.AtomicLong;

import java.util.concurrent.atomic.LongAdder;

public class ThreadSecurityDemo {

private int count=0;

// 同步代码块的方式

public void testSync() throws InterruptedException {

for (int i = 0; i < 3; i++) {

new Thread(() -> {

long starttime = System.currentTimeMillis();

while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒

synchronized (this) {

++count;

}

}

long endtime = System.currentTimeMillis();

System.out.println("同步代码块执行时间：" + (endtime - starttime) + "毫秒，" + "执行自加次数：" + count);

}).start();

}

}

// Atomic方式

private AtomicLong acount = new AtomicLong(0L);

public void testAtomic() throws InterruptedException {

for (int i = 0; i < 3; i++) {

new Thread(() -> {

long starttime = System.currentTimeMillis();

while (System.currentTimeMillis() - starttime < 2000) {

acount.incrementAndGet();

}

long endtime = System.currentTimeMillis();

System.out.println("Atomic方式执行时间：" + (endtime - starttime) + "毫秒，" + "执行自加次数：" + acount.incrementAndGet());

}).start();

}

}

// LongAdder 方式

private LongAdder lacount = new LongAdder();

public void testLongAdder() throws InterruptedException {

for (int i = 0; i < 3; i++) {

new Thread(() -> {

long starttime = System.currentTimeMillis();

while (System.currentTimeMillis() - starttime < 2000) {

lacount.increment();

}

long endtime = System.currentTimeMillis();

System.out.println("LongAdder方式执行时间：" + (endtime - starttime) + "毫秒，" + "执行自加次数：" + lacount.sum());

}).start();

}

}

public static void main(String[] args) throws InterruptedException {

ThreadSecurityDemo demo = new ThreadSecurityDemo();

demo.testSync();

demo.testAtomic();

demo.testLongAdder();

}

}

通过执行次数我们可以直观比较执行效率:

LongAdder方式 > AtomicLong方式 > 同步代码块方式

Java 线程安全之原子性相关教程

java基础知识点笔记

java基础知识点笔记 基础知识点 abstract表明类或者成员方法具有抽象属性assert断言，用来进行程序调试boolean基本数据类型之一，声明布尔类型的关键字break提前跳出一个块byte基本数据类型之一，字节类型case用在switch语句之中，表示其中的一个分支catch用

蓝桥杯第六届牌型种数(Java)

蓝桥杯第六届牌型种数(Java) 暴力： public class Main { public static void main(String[] args) { int[] a = new int[13]; int count = 0; for (a[0] = 0; a[0] = 4; a[0]++) for (a[1] = 0; a[1] = 4; a[1]++) for (a[2] = 0; a[2] = 4; a[2]++) for (a

第76课 多线程间的互斥(下)

第76课 多线程间的互斥(下) 一、多线程间的互斥 问题：程序有多少临界资源？需要多少线程锁？ 一般性原则：每一个临界资源都需要一个线程锁进行保护 死锁发生： main.cpp #include QCoreApplication#include QThread#include QDebug#include QMutexQMutex g

java学习笔记day2【基础语法】

java学习笔记day2【基础语法】 二、语法 ps：基本常识 熟悉psvm和sout 可以执行 改注释颜色的时候遇到些问题，可能是因为免费版改不了，画圈的都点不了 //单行注释/*多行注释多行注释多行注释*/ 注意事项： 所有的标识符都应该以字母、$、或者_开头。 首字母

Java NIO学习，一次读懂Java NIO

Java NIO学习，一次读懂Java NIO Java NIO 和 IO 的区别 缓冲区存取数据的两个核心方法 put：存入数据到缓冲区 get：获取缓冲区中的数据 缓冲区的四个核心属性 capacity：容量，表示缓冲区中最大存储数据的容量，一旦声明不能改变 position：位置，表示缓冲区

Java运行时数据区(Run-time data areas)

Java运行时数据区(Run-time data areas) Run-time data areas PC (program counter):存放指令位置 虚拟机的运行类似如下循环 while(not end) {取PC中的位置，找到对应位置的指令；执行该指令；PC++；} JVM stacks ：每个java线程独有一个栈，里面装的是栈帧，

Getting started with Java EE 8 MVC(1)

Getting started with Java EE 8 MVC(1) 为什么80%的码农都做不了架构师？ Getting started with Java EE 8 MVC MVC is a new specification introduced in the upcoming Java EE 8. It is based on the existing JAXRS. At the moment I wrote down these po

LintCode 213. 字符串压缩 JavaScript算法

LintCode 213. 字符串压缩 JavaScript算法 描述 设计一种方法，通过给重复字符计数来进行基本的字符串压缩。 例如，字符串 aabcccccaaa 可压缩为 a2b1c5a3 。而如果压缩后的字符数不小于原始的字符数，则返回原始的字符串。 可以假设字符串仅包括 a-z 的字母