java JUC学习笔记

主要内容

1.Java JUC 简介
2.volatile 关键字-内存可见性
3.原子变量-CAS算法
4.ConcurrentHashMap 锁分段机制
5.CountDownLatch 闭锁
6.实现 Callable 接口
7.Lock 同步锁
8.Condition 控制线程通信
9.ReadWriteLock 读写锁
10.线程池
11.ForkJoinPool 分支/合并框架工作窃取
思维导图

Java JUC 简介

在 Java 5.0 提供了 java.util.concurrent （简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。

volatile 关键字-内存可见性

• 内存可见性
  内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的 volatile 变量。
• 没有加volatile关键字修饰的共享变量只打印true。

public class TestVolatile {
	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo();
		new Thread(td).start();
		while(true){
			if(td.isFlag()){
				System.out.println("-------------------------");
				break;
			}
		}
	}
}
class ThreadDemo implements Runnable{
	private boolean flag=false;
	@Override
	public void run() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		flag=true;
		System.out.println("flag:"+flag);
		
	}
	public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	
}

• 代码图解
  

原子变量-CAS算法

CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。CAS 是一种无锁的非阻塞算法的实现。
CAS 包含了 3 个操作数：

• 需要读写的内存值 V
• 旧的预期值 A
• 拟写入的新值 B
  当且仅当 V 的值等于 A 时，CAS 通过原子方式用新值 B 来更新 V 的值，否则不会执行任何操作。

ConcurrentHashMap 锁分段机制

Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段”机制替代 Hashtable 的独占锁。进而提高性能。
此包还提供了设计用于多线程上下文中的 Collection 实现：
ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、 CopyOnWriteArrayList 和CopyOnWriteArraySet。当期望许多线程访问一个给定collection 时，ConcurrentHashMap 通常优于同步的 HashMap，
ConcurrentSkipListMap 通常优于同步的 TreeMap。当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的 ArrayList。

• 使用传统的加锁机制,下面代码会报并发访问异常

public class TestCopyOnWriteList {
	public static void main(String[] args) {
		HelloThread ht=new HelloThread();
		new Thread(ht).start();
	}

}
class HelloThread implements Runnable{
	private static List<String> list=Collections.synchronizedList(new ArrayList<String>());
	static{
		list.add("hello");
		list.add("jack");
		list.add("tom");
	}
	@Override
	public void run() {
		Iterator it=list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
			list.add("tony");
		}
	}
	
}

• 将上面的代码修改成CopyOnWriteArrayList问题解决,原因是每次写入的时候会复制一份。
  但是注意：因为复制会带来很大的开销所以要慎用，如果迭代操作多，写入操作少可以考虑用它。

//private static List<String> list=Collections.synchronizedList(new ArrayList<String>());
	private static CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<>();
	static{
		list.add("hello");
		list.add("jack");
		list.add("tom");
	}

CountDownLatch 闭锁

Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。
CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：
确保某个计算在其需要的所有资源都被初始化之后才继续执行;
确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
等待直到某个操作所有参与者都准备就绪再继续执行。

• 闭锁demo统计5个线程计算10000以内的偶数说花的时间

public class TestCountDownLatch {
	public static void main(String[] args) {
		final CountDownLatch cdl=new CountDownLatch(5);
		CountDownLatchThread cdlt=new CountDownLatchThread(cdl);
		LocalDateTime start=LocalDateTime.now();
		for(int i=0;i<5;i++){
			new Thread(cdlt).start();
		}
		try {
			//等其他线程都运算完成才进行运算
			cdl.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		LocalDateTime end=LocalDateTime.now();
		Duration d=Duration.between(start, end);
		System.out.println("计算所执行的时间为"+d.toMillis());
	}
}
class CountDownLatchThread implements Runnable{
	private CountDownLatch cdl;
	public CountDownLatchThread(CountDownLatch cdl) {
		this.cdl=cdl;
	}
	@Override
	public void run() {
		
		synchronized (this) {
			try{
				for(int i=0;i<10000;i++){
					if(i%2==0){
						System.out.println(i);
					}
				}
			}finally{
				//一个线程执行完就减一
				cdl.countDown();
			}
		}
	}
	
}

实现 Callable 接口

Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
Callable 需要依赖FutureTask的支持 ，FutureTask 也可以用作闭锁

• demo

public class TestCallable {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ThreadCallable tc=new ThreadCallable();
		//必须配合它来使用，创建线程有四种方式
		FutureTask<Integer> result=new FutureTask<>(tc);
		new Thread(result).start();
		System.out.println(result.get());
	}
}
class ThreadCallable implements Callable<Integer>{
	
	@Override
	public Integer call() throws Exception {
		Integer sum=0;
		for(int i=0;i<=100;i++){
			sum+=i;
		}
		return sum;
	}
	
}

Lock 同步锁

在 Java 5.0 之前，协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制，但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能。
ReentrantLock 实现了 Lock 接口，并提供了与 synchronized 相同的互斥性和内存可见性。但相较于 synchronized 提供了更高的处理锁的灵活性。

• 卖票案例

public class TestLock {
	public static void main(String[] args) {
		LockDemo ld = new LockDemo();
		new Thread(ld).start();
		new Thread(ld).start();
		new Thread(ld).start();
		new Thread(ld).start();
	}
}

class LockDemo implements Runnable {
	private int ticket = 100;
	private Lock lock = new ReentrantLock();
	@Override
	public void run() {
		while (true) {
			try {
				lock.lock();
				Thread.sleep(200);
				if (ticket > 0) {
					System.out.println("第" + Thread.currentThread().getName() + "号窗口卖票，剩余票数" + ticket--);
				}
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				lock.unlock();
			}

		}

	}

}

Condition 控制线程通信

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。
在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是await、signal 和 signalAll。Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例，请使用其 newCondition() 方法。

ReadWriteLock 读写锁

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。

public class TestReadWriteLock {
	public static void main(String[] args) {
		ReadWriteLockDemo dwld=new ReadWriteLockDemo();
		new Thread(()->dwld.write(),"写锁").start();
		for(int i=0;i<100;i++){
			new Thread(()->dwld.read(),"读锁").start();
		}
	}
}
class ReadWriteLockDemo{
	private int number=1;
	private ReadWriteLock rwl=new ReentrantReadWriteLock();
	public void read(){
		rwl.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName()+"\t"+number);
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			rwl.readLock().unlock();
		}
	}
	public void write(){
		rwl.writeLock().lock();
		try {
			Thread.sleep(200);
			System.out.println(Thread.currentThread().getName()+"\t"+number);
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			rwl.writeLock().unlock();
		}
	}
}

线程池

第四种获取线程的方法：线程池，一个 ExecutorService，它使用可能的几个池线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置。
线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。
为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子 (hook)。但是，强烈建议程序员使用较为方便的 Executors 工厂方法：
Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）
Executors.newFixedThreadPool(int)（固定大小线程池）
Executors.newSingleThreadExecutor()（单个后台线程）
它们均为大多数使用场景预定义了设置。

• 线程池使用方法demo

public class TestThreadPool {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建容量为5的固定线程池
		ExecutorService pool=Executors.newFixedThreadPool(5);
		//可以是Runnable接口
		/*pool.submit(()->{
			System.out.println("线程池测试");
		});*/
		//也可以是Callable接口
		Future<Integer> future=pool.submit(()->{
			//为线程分配任务
			int sum=0;
			for(int i=1;i<=100;i++){
				sum+=i;
			}
			return sum;
		});
		System.out.println(future.get());
		//立即关闭线程池
		//pool.shutdownNow();
		//等线程池中的线程执行完毕再关闭
		pool.shutdown();
	}
}

• 线程调度,ScheduledExecutorService newScheduledThreadPool(),建立固定大小的线程，可以延迟或者定时执行任务

ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
		// 为线程分配十个任务
		for (int i = 0; i < 10; i++) {
			Future<Integer> future = pool.schedule(() -> {
				int num = new Random().nextInt(100);
				System.out.println(Thread.currentThread().getName() + "  " + num);
				return num;
				//每隔一面为一个线程分配任务
			}, 1, TimeUnit.SECONDS);
		}
		pool.shutdown();

ForkJoinPool 分支/合并框架工作窃取

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总。

• Fork/Join 框架与线程池的区别
  采用 “工作窃取”模式（work-stealing）：
  当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加
  到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。
  相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间，提高了性能。
• demo

public static void main(String[] args) {
		//依赖于ForkJoinPool执行
		ForkJoinPool pool=new ForkJoinPool();
		ForkJoinTask<Long> fjsc=new ForkJoinSumCalculate(0L, 1000000000L);
		Long sum=pool.invoke(fjsc);
		System.out.println(sum);
	}
	class ForkJoinSumCalculate extends RecursiveTask<Long>{

	private static final long serialVersionUID = 1L;
	private long start;
	private long end;
	private static final long THURSHOLD=10000L;//临界值
	public ForkJoinSumCalculate(long start,long end) {
		this.start=start;
		this.end=end;
	}
	@Override
	protected Long compute() {
		long length=end-start;
		if(length<=THURSHOLD){
			long sum=0L;
			for(long i=start;i<end;i++){
				sum+=i;
			}
			return sum;
		}else{
			//如果超过临界值则进行拆分
			long midlle=start+end/2;
			ForkJoinSumCalculate left=new ForkJoinSumCalculate(start, midlle);
			left.fork();//进行拆分同时压入线程队列
			ForkJoinSumCalculate right=new ForkJoinSumCalculate(midlle+1, end);
			right.fork();
			return left.join()+right.join();
		}
	}
	
}

• java8新特性对Fork/join框架的支持

@Test
	public void test(){
		//串行的方法,执行时间：65043
		Instant start=Instant.now();
		long sum=0;
		for(Long i=1L;i<10000000000L;i++){
			sum+=i;
		}
		Instant end=Instant.now();
		Duration d=Duration.between(start, end);
		System.out.println(d.toMillis());
	}
	/**
	 * Java8的方式，执行时间2788
	 */
	@Test
	public void test2(){
		Instant start=Instant.now();
		Long sum=LongStream.rangeClosed(0L,10000000000L).parallel().reduce(0L,Long::sum);
		Instant end=Instant.now();
		Duration d=Duration.between(start, end);
		System.out.println(d.toMillis());
	}