JUC

1、Java JUC简介

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

2、volatile关键字--内存可见性：内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

内存可见性问题是指当多个线程操作共享数据的时候，彼此之间对共享数据是不可见的。
volatile关键字声明的变量当多个线程操作共享数据的时候，彼此线程之间对该共享数据是可见的。
volatile相较于对共享数据什么限制都没有的情况，效率会稍微降低，但是volatile要比锁的效率高很多
volatile和synchronized的比较：volatile相较于synchronized是一种轻量级的同步策略，volatile不具备互斥性也不能保证变量的原子性

3、原子变量-CAS算法

原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将 volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

　　原子操作表达的意思是要么一个操作成功，要么失败，中间过程不会被其他的线程中断，这一点对于并发编程来说非常重要，在java中使用了大量的CAS来做并发编程，包括jdk的ConcurrentHsahMap的实现，还有AtomicXXX的实现等其他一些并发工具的实现都使用了CAS这种技术，CAS包括两部分，也就是Compare and swap，首先是比较，然后再交互，这样做的原因是，在并发环境下，可能不止一个线程想要来改变某个共享变量的值，那么在进行操作之前使用一个比较，而这个比较的值是当前线程认为（知道）该共享变量最新的值，但是可能其他线程已经改变了这个值，那么此时CAS操作就会失败，只有在共享变量的值等于线程提供的用于比较的值的时候才会进行原子改变操作。

1. volatile 保证内存可见性
2. CAS（Compare-And-Swap）算法保证数据变量的原子性
　　CAS 算法是硬件对于并发操作共享数据的支持

　　CAS算法是一种无锁非阻塞算法，因此这种算法比原来一般的同步锁效率要高很多
　　CAS 包含了三个操作数：
　　①内存值 V
　　②预估值（旧值） A
　　③更新值 B
　　当且仅当 V == A 时， V = B; 否则，不会执行任何操作。

3.atomic包下提供了很多原子变量，用法就相当于包装类差不多

4、模拟CAS算法的代码实现：

 1 package com.baozi.juc;
 2 
 3 /*
 4  * 模拟 CAS 算法
 5  */
 6 public class TestCompareAndSwap {
 7 
 8     public static void main(String[] args) {
 9         final CompareAndSwap cas = new CompareAndSwap();
10         
11         for (int i = 0; i < 10; i++) {
12             new Thread(new Runnable() {
13                 
14                 @Override
15                 public void run() {
16                     int expectedValue = cas.get();
17                     boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
18                     System.out.println(b);
19                 }
20             }).start();
21         }
22         
23     }
24     
25 }
26 
27 class CompareAndSwap{
28     private int value;
29     
30     //获取内存值
31     public synchronized int get(){
32         return value;
33     }
34     
35     //比较
36     public synchronized int compareAndSwap(int expectedValue, int newValue){
37         int oldValue = value;
38         
39         if(oldValue == expectedValue){
40             this.value = newValue;
41         }
42         
43         return oldValue;
44     }
45     
46     //设置
47     public synchronized boolean compareAndSet(int expectedValue, int newValue){
48         return expectedValue == compareAndSwap(expectedValue, newValue);
49     }
50 }

4、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。

注意：List<String> list = Collections.synchronizedList(new ArrayList<String>())使用这种方法无法实现某一线程在同一时刻对集合的读并写的操作，因为这是复合操作，会出现并发修改异常。

代码展示：

 1 package com.baozi.juc;
 2 
 3 import java.util.Iterator;
 4 import java.util.concurrent.CopyOnWriteArrayList;
 5 
 6 /*
 7  * CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制”
 8  * 注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。
 9  */
10 public class TestCopyOnWriteArrayList {
11     public static void main(String[] args) {
12         HelloThread ht = new HelloThread();
13         
14         for (int i = 0; i < 10; i++) {
15             new Thread(ht).start();
16         }
17     }
18 }
19 
20 class HelloThread implements Runnable{
21     
22 //    private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
23     
24     private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
25     static{
26         list.add("AA");
27         list.add("BB");
28         list.add("CC");
29     }
30 
31     @Override
32     public void run() {
33         Iterator<String> it = list.iterator();
34         while(it.hasNext()){
35             System.out.println(it.next());
36             
37             list.add("AA");
38         }
39     }
40 }

View Code

　　ConcurrentHashMap是线程安全的，Hashtable是非严格意义上的线程安全。
　　当多线程同时访问Hashtable时，它使用的安全机制是把整个表全部锁起来，这样同一时间不管是增删改查只能有一个线程能够操作这个表，相当于是把并行操作变成了串行操作，效率是非常低的，而且hashtable对复合操作是线程不安全的，换言之它不是严格的线程安全。

　　ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁ReentrantLock，在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构，一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素， 每个Segment守护者一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。

注意：

　　在java 7中，ConcurrentHashMap的实现是基于分段锁协议的实现，本质上还是使用了锁，只是基于一种考虑，就是多个线程访问哈希桶具有随机性，基于这种考虑来将数据存储在不同的哈希段上面，然后每一个段配有一把锁，在需要写某个段的时候需要加锁，而在这个时候，其他访问其他段的线程是不需要阻塞的，但是对于该段的线程访问就需要等待，直到这个加锁的线程释放了锁，其他线程才能进行访问。

　　在java 8中，ConcurrentHashMap的实现抛弃了这种复杂的架构设计，但是继承了这种分散线程竞争压力的思想，其实就提高系统的并发度这一维度来说，分散竞争压力是一种最为直接明了的解决方案，而java 8在实现ConcurrentHashMap的时候大量使用了CAS操作，减少了使用锁的频度来提高系统的响应度，其实使用锁和使用CAS来做并发在复杂度上不是一个数量级的，使用锁在很大程度上假设了多个线程的排斥性，并且使用锁会将线程阻塞等待，也就是说使用锁来做线程同步的时候，线程的状态是会改变的，但是使用CAS是不会改变线程的状态的（不太严谨的说），所以使用CAS比起使用synchronized或者使用Lcok来说更为轻量级。

5、CountDownLatch-闭锁

 1 package com.atguigu.juc;
 2 
 3 import java.util.concurrent.CountDownLatch;
 4 
 5 /*
 6  * CountDownLatch ：闭锁，在完成某些运算是，只有其他所有线程的运算全部完成，当前运算才继续执行
 7  */
 8 public class TestCountDownLatch {
 9 
10     public static void main(String[] args) {
11         final CountDownLatch latch = new CountDownLatch(50);
12         LatchDemo ld = new LatchDemo(latch);
13 
14         long start = System.currentTimeMillis();
15 
16         for (int i = 0; i < 50; i++) {
17             new Thread(ld).start();
18         }
19 
20         try {
21             //当for()循环中的分线程没有执行完毕之前主线程一直等待
22             latch.await();
23         } catch (InterruptedException e) {
24         }
25 
26         long end = System.currentTimeMillis();
27 
28         System.out.println("耗费时间为：" + (end - start));
29     }
30 
31 }
32 
33 class LatchDemo implements Runnable {
34 
35     private CountDownLatch latch;
36 
37     public LatchDemo(CountDownLatch latch) {
38         this.latch = latch;
39     }
40 
41     @Override
42     public void run() {
43        synchronized(this){
44            try {
45                 for (int i = 0; i < 50000; i++) {
46                     if (i % 2 == 0) {
47                         System.out.println(i);
48                     }
49                 }
50             } finally {
51                 //每经过一线程执行该for()循环，final CountDownLatch latch = new CountDownLatch(50);构造器中传入的参数就减一，
52                 //直到为零，证明所有的线程执行完毕
53                 latch.countDown();
54             }
55         }
56     }
57 
58 }

View Code

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

6、Condition控制线程通信

　　Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题， Condition 方法的名称与对应的 Object 版本中的不同。

　　在 Condition 对象中，与 wait、 notify 和 notifyAll 方法对应的分别是await、 signal 和 signalAll。

　　Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例，请使用其 newCondition() 方法。

7、线程八锁

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
加个普通方法后发现和同步锁无关
所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象

 1 package com.baozi.juc;
 2 
 3 /*
 4  * 题目：判断打印的 "one" or "two" ？
 5  * 
 6  * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one  two
 7  * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one  two
 8  * 3. 新增普通方法 getThree() , 打印? //three  one   two
 9  * 4. 两个普通同步方法，两个 Number 对象，打印?  //two  one
10  * 5. 修改 getOne() 为静态同步方法，打印?  //two   one
11  * 6. 修改两个方法均为静态同步方法，一个 Number 对象?  //one   two
12  * 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象?  //two  one
13  * 8. 两个静态同步方法，两个 Number 对象?   //one  two
14  * 
15  * 线程八锁的关键：
16  * ①非静态方法的锁默认为  this,  静态方法的锁为 对应的 Class 实例
17  * ②某一个时刻内，只能有一个线程持有锁，无论几个方法。
18  */
19 public class TestThread8Monitor {
20     
21     public static void main(String[] args) {
22         Number number = new Number();
23         Number number2 = new Number();
24         
25         new Thread(new Runnable() {
26             @Override
27             public void run() {
28                 number.getOne();
29             } 
30         }).start();
31         
32         new Thread(new Runnable() {
33             @Override
34             public void run() {
35 //                number.getTwo();
36                 number2.getTwo();
37             }
38         }).start();
39         
40         /*new Thread(new Runnable() {
41             @Override
42             public void run() {
43                 number.getThree();
44             }
45         }).start();*/
46         
47     }
48 
49 }
50 
51 class Number{
52     
53     public static synchronized void getOne(){//Number.class
54         try {
55             Thread.sleep(3000);
56         } catch (InterruptedException e) {
57         }
58         
59         System.out.println("one");
60     }
61     
62     public synchronized void getTwo(){//this
63         System.out.println("two");
64     }
65     
66     public void getThree(){
67         System.out.println("three");
68     }
69     
70 }

8、线程按序交替

  1 package com.atguigu.juc;
  2 
  3 import java.util.concurrent.locks.Condition;
  4 import java.util.concurrent.locks.Lock;
  5 import java.util.concurrent.locks.ReentrantLock;
  6 
  7 /*
  8  * 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。
  9  *    如：ABCABCABC…… 依次递归
 10  */
 11 public class TestABCAlternate {
 12     
 13     public static void main(String[] args) {
 14         AlternateDemo ad = new AlternateDemo();
 15         //启动一个线程把A打印20次
 16         new Thread(new Runnable() {
 17             @Override
 18             public void run() {
 19                 //打印A的时候调用loopA()
 20                 for (int i = 1; i <= 20; i++) {
 21                     ad.loopA(i);
 22                 }
 23                 
 24             }
 25         }, "A").start();
 26         //启动一个线程把B打印20次
 27         new Thread(new Runnable() {
 28             @Override
 29             public void run() {
 30                 //打印B的时候调用loopB()
 31                 for (int i = 1; i <= 20; i++) {
 32                     ad.loopB(i);
 33                 }
 34                 
 35             }
 36         }, "B").start();
 37         //启动一个线程把C打印20次
 38         new Thread(new Runnable() {
 39             @Override
 40             public void run() {
 41                 //打印C的时候调用loopC()
 42                 for (int i = 1; i <= 20; i++) {
 43                     ad.loopC(i);
 44                     
 45                     System.out.println("-----------------------------------");
 46                 }
 47                 
 48             }
 49         }, "C").start();
 50     }
 51 
 52 }
 53 
 54 class AlternateDemo{
 55     
 56     private int number = 1; //当前正在执行线程的标记
 57     
 58     private Lock lock = new ReentrantLock();
 59     private Condition condition1 = lock.newCondition();
 60     private Condition condition2 = lock.newCondition();
 61     private Condition condition3 = lock.newCondition();
 62     
 63     /**
 64      * @param totalLoop : 循环第几轮
 65      */
 66     public void loopA(int totalLoop){
 67         lock.lock();
 68         
 69         try {
 70             //1. 判断
 71             if(number != 1){
 72                 condition1.await();
 73             }
 74             
 75             //2. 打印
 76             for (int i = 1; i <= 1; i++) {
 77                 System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
 78             }
 79             
 80             //3. 唤醒
 81             number = 2;
 82             condition2.signal();
 83         } catch (Exception e) {
 84             e.printStackTrace();
 85         } finally {
 86             lock.unlock();
 87         }
 88     }
 89     
 90     public void loopB(int totalLoop){
 91         lock.lock();
 92         
 93         try {
 94             //1. 判断
 95             if(number != 2){
 96                 condition2.await();
 97             }
 98             
 99             //2. 打印
100             for (int i = 1; i <= 1; i++) {
101                 System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
102             }
103             
104             //3. 唤醒
105             number = 3;
106             condition3.signal();
107         } catch (Exception e) {
108             e.printStackTrace();
109         } finally {
110             lock.unlock();
111         }
112     }
113     
114     public void loopC(int totalLoop){
115         lock.lock();
116         
117         try {
118             //1. 判断
119             if(number != 3){
120                 condition3.await();
121             }
122             
123             //2. 打印
124             for (int i = 1; i <= 1; i++) {
125                 System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
126             }
127             
128             //3. 唤醒
129             number = 1;
130             condition1.signal();
131         } catch (Exception e) {
132             e.printStackTrace();
133         } finally {
134             lock.unlock();
135         }
136     }
137     
138 }

9、ReadWriteLock读写锁

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

 1 package com.atguigu.juc;
 2 
 3 import java.util.concurrent.locks.ReadWriteLock;
 4 import java.util.concurrent.locks.ReentrantReadWriteLock;
 5 
 6 /*
 7  * 1. ReadWriteLock : 读写锁
 8  * 
 9  * 写写/读写 需要“互斥”
10  * 读读 不需要互斥
11  * 
12  */
13 public class TestReadWriteLock {
14 
15     public static void main(String[] args) {
16         ReadWriteLockDemo rw = new ReadWriteLockDemo();
17         
18         new Thread(new Runnable() {
19             
20             @Override
21             public void run() {
22                 rw.set((int)(Math.random() * 101));
23             }
24         }, "Write:").start();
25         
26         
27         for (int i = 0; i < 100; i++) {
28             new Thread(new Runnable() {
29                 
30                 @Override
31                 public void run() {
32                     rw.get();
33                 }
34             }).start();
35         }
36     }
37     
38 }
39 
40 class ReadWriteLockDemo{
41     
42     private int number = 0;
43     
44     private ReadWriteLock lock = new ReentrantReadWriteLock();
45     
46     //读
47     public void get(){
48         lock.readLock().lock(); //上锁
49         
50         try{
51             System.out.println(Thread.currentThread().getName() + " : " + number);
52         }finally{
53             lock.readLock().unlock(); //释放锁
54         }
55     }
56     
57     //写
58     public void set(int number){
59         lock.writeLock().lock();
60         
61         try{
62             System.out.println(Thread.currentThread().getName());
63             this.number = number;
64         }finally{
65             lock.writeLock().unlock();
66         }
67     }
68 }

10、ForkJoinPool 分支合并框架--工作窃取

Fork/Join 框架：

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

Fork/Join 框架与线程池的区别：
　　采用 “工作窃取”模式（work-stealing）：相对于一般的线程池实现， fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间，提高了性能。

posted @ 2019-04-19 19:15 包子的百草园阅读(258) 评论(0) 编辑收藏举报

刷新页面返回顶部

JUC