Java 中有哪些无锁技术来解决并发问题?如何使用?

2019-09-29   阅读(266)  

除了使用 synchronized、Lock 加锁之外,Java 中还有很多不需要加锁就可以解决并发问题的工具类

 

1、原子工具类

JDK 1.8 中,java.util.concurrent.atomic 包下类都是原子类,原子类都是基于 sun.misc.Unsafe 实现的。

  • CPU 为了解决并发问题,提供了 CAS 指令,全称 Compare And Swap,即比较并交互
  • CAS 指令需要 3 个参数,变量、比较值、新值。当变量的当前值与比较值相等时,才把变量更新为新值
  • CAS 是一条 CPU 指令,由 CPU 硬件级别上保证原子性
  • java.util.concurrent.atomic 包中的原子分为:原子性基本数据类型、原子性对象引用类型、原子性数组、原子性对象属性更新器和原子性累加器

原子性基本数据类型:AtomicBoolean、AtomicInteger、AtomicLong

原子性对象引用类型:AtomicReference、AtomicStampedReference、AtomicMarkableReference

原子性数组:AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

原子性对象属性更新:AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

原子性累加器:DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder

 

修改我们之前测试原子性问题的类,使用 AtomicInteger 的简单例子

package constxiong.concurrency.a026;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 测试 原子类 AtomicInteger
 * 
 * @author ConstXiong
 */
public class TestAtomicInteger {

	// 计数变量
	static volatile AtomicInteger count = new AtomicInteger(0);

	public static void main(String[] args) throws InterruptedException {
		// 线程 1 给 count 加 10000
		Thread t1 = new Thread(() -> {
			for (int j = 0; j < 10000; j++) {
				count.incrementAndGet();
			}
			System.out.println("thread t1 count 加 10000 结束");
		});

		// 线程 2 给 count 加 10000
		Thread t2 = new Thread(() -> {
			for (int j = 0; j < 10000; j++) {
				count.incrementAndGet();
			}
			System.out.println("thread t2 count 加 10000 结束");
		});

		// 启动线程 1
		t1.start();
		// 启动线程 2
		t2.start();

		// 等待线程 1 执行完成
		t1.join();
		// 等待线程 2 执行完成
		t2.join();

		// 打印 count 变量
		System.out.println(count.get());
	}

}

 

打印结果如预期

thread t2 count 加 10000 结束
thread t1 count 加 10000 结束
20000

 

2、线程本地存储

  • java.lang.ThreadLocal 类用于线程本地化存储。
  • 线程本地化存储,就是为每一个线程创建一个变量,只有本线程可以在该变量中查看和修改值。
  • 典型的使用例子就是,spring 在处理数据库事务问题的时候,就用了 ThreadLocal 为每个线程存储了各自的数据库连接 Connection。
  • 使用 ThreadLocal 要注意,在不使用该变量的时候,一定要调用 remove() 方法移除变量,否则可能造成内存泄漏的问题。

 

示例

package constxiong.concurrency.a026;

/**
 * 测试 原子类 AtomicInteger
 * 
 * @author ConstXiong
 */
public class TestThreadLocal {

	// 线程本地存储变量
	private static final ThreadLocal<Integer> THREAD_LOCAL_NUM = new ThreadLocal<Integer>() {
		@Override
		protected Integer initialValue() {//初始值
			return 0;
		}
	};

	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {// 启动三个线程
			Thread t = new Thread() {
				@Override
				public void run() {
					add10ByThreadLocal();
				}
			};
			t.start();
		}
	}

	/**
	 * 线程本地存储变量加 5
	 */
	private static void add10ByThreadLocal() {
		try {
			for (int i = 0; i < 5; i++) {
				Integer n = THREAD_LOCAL_NUM.get();
				n += 1;
				THREAD_LOCAL_NUM.set(n);
				System.out.println(Thread.currentThread().getName() + " : ThreadLocal num=" + n);
			}
		} finally {
			THREAD_LOCAL_NUM.remove();// 将变量移除
		}
	}
}

 

每个线程最后一个值都打印到了 5

Thread-0 : ThreadLocal num=1
Thread-2 : ThreadLocal num=1
Thread-1 : ThreadLocal num=1
Thread-2 : ThreadLocal num=2
Thread-0 : ThreadLocal num=2
Thread-2 : ThreadLocal num=3
Thread-0 : ThreadLocal num=3
Thread-1 : ThreadLocal num=2
Thread-0 : ThreadLocal num=4
Thread-2 : ThreadLocal num=4
Thread-0 : ThreadLocal num=5
Thread-1 : ThreadLocal num=3
Thread-2 : ThreadLocal num=5
Thread-1 : ThreadLocal num=4
Thread-1 : ThreadLocal num=5

 

3、copy-on-write

  • 根据英文名称可以看出,需要写时复制,体现的是一种延时策略。
  • Java 中的 copy-on-write 容器包括:CopyOnWriteArrayList、CopyOnWriteArraySet。
  • 涉及到数组的全量复制,所以也比较耗内存,在写少的情况下使用比较适合。

 

简单的 CopyOnWriteArrayList 的示例,这里只是说明 CopyOnWriteArrayList 怎么用,并且是线程安全的。这个场景并不适合使用 CopyOnWriteArrayList,因为写多读少。

package constxiong.concurrency.a026;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 测试 copy-on-write
 * @author ConstXiong
 */
public class TestCopyOnWrite {

	private static final Random R = new Random();
	
	private static CopyOnWriteArrayList<Integer> cowList = new CopyOnWriteArrayList<Integer>();
//	private static ArrayList<Integer> cowList = new ArrayList<Integer>();
	
	public static void main(String[] args) throws InterruptedException {
		List<Thread> threadList = new ArrayList<Thread>();
		//启动 1000 个线程,向 cowList 添加 5 个随机整数
		for (int i = 0; i < 1000; i++) {
			Thread t = new Thread(() -> {
				for (int j = 0; j < 5; j++) {
					//休眠 10 毫秒,让线程同时向 cowList 添加整数,引出并发问题
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					cowList.add(R.nextInt(100));
				}
			}) ;
			t.start();
			threadList.add(t);
		}
		
		for (Thread t : threadList) {
			t.join();
		}
		System.out.println(cowList.size());
	}
}

 

打印结果

5000

 

如果把

private static CopyOnWriteArrayList<Integer> cowList = new CopyOnWriteArrayList<Integer>();

改为

private static ArrayList<Integer> cowList = new ArrayList<Integer>();

 

打印结果就是小于 5000 的整数了

 

ConstXiong 备案号:苏ICP备16009629号-3