JUC总结

1、volatile关键字

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

volatile 变量，用来确保将变量的更新操作通知到其他线程，保证内存中的数据可见。

• 不具备互斥性
• 不能保证原子性（操作不可分割）

2、原子变量

java.util.concurrent.atomic 包下提供了一些原子操作的常用类:

• AtomicBoolean 、 AtomicInteger 、 AtomicLong 、 AtomicReference
• AtomicIntegerArray 、 AtomicLongArray
• AtomicMarkableReference
• AtomicReferenceArray
• AtomicStampedReference

特性：

• 使用了volatile保证内存可见性
• CAS（compare-and-swap）算法保证数据的原子性
• 核心方法： boolean compareAndSet(expectedValue, updateValue)

CAS算法

CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。

CAS 是一种无锁的非阻塞算法的实现。（因为非阻塞，一次执行不成功，会立即执行第二次操作，不会阻塞，这样就比同步锁的方式效率高）

 

CAS 包含了 3 个操作数：

• 需要读写的内存值 V
• 进行比较的值 A，第二次从内存中读到的值，期待值
• 拟写入的新值 B

当且仅当 V 的值等于 A 时， CAS 通过原子方式用新值 B 来更新 V 的值，否则不会执行任何操作

//cas算法原理
class CompareAndSwap {
    private int value;
    //获取内存值
    public synchronized int get() {
        return value;
    }
    //比较
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;
        if (oldValue == expectedValue) {
            this.value = newValue;
        }
        return oldValue;
    }
    //设置
    public synchronized boolean compareAndSet(int expectedValue, int newValue) {
        return expectedValue == compareAndSwap(expectedValue, newValue);
    }
}

3、ConcurrentHashMap 锁分段机制

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

jdk8以后取消了锁分段机制，底层使用cas

4、CountDownLatch 闭锁

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

//使用方法：例如计算多线程的总共执行时间
public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch latch = new CountDownLatch(10);
        LatchDemo latchDemo = new LatchDemo(latch);
 
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            new Thread(latchDemo).start();
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("执行耗时:"+(end-start));
    }
}
 
class LatchDemo implements Runnable {
    private CountDownLatch latch;
    public LatchDemo(CountDownLatch latch) {
        this.latch = latch;
    }
 
    @Override
    public void run() {
        synchronized (latch) {
            try {
                for (int i = 0; i < 50000; i++) {
                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            } finally {
                latch.countDown();
            }
        }
    }
}

5、实现 Callable 接口

创建线程的方式

• 继承Thread类
• 实现Runable接口
• 实现Callable接口
• 线程池

相较于Runable接口的区别：

• 方法可以有返回值，返回值类型就是Callable接口的泛型
• 可以抛出异常
• 执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。  FutureTask 是  Future 接口的实现类
• FutureTask.get()方法需要等线程执行完了，才会执行，所以可用于闭锁的操作

public class TestCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadDemo1 td = new ThreadDemo1();
 
        //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
        FutureTask<Integer> result = new FutureTask<>(td);
        new Thread(result).start();
 
        //2.接收线程运算后的结果
        Integer sum = result.get();  //FutureTask 可用于 闭锁
        System.out.println(sum);
    }
}
 
class ThreadDemo1 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100000; i++) {
            sum += i;
        }
        return sum;
    }
}

6、Lock 同步锁

用于解决多线程安全问题的三种方式

• 同步代码块：synchronized关键字
• 同步方法：synchronized关键字
• 同步锁Lock：jdk5之后出现
• 是一个显示的锁，通过lock()方法上锁，通过unlock()方法释放锁

public class TestLock {
   public static void main(String[] args) {
      Ticket ticket = new Ticket();
      new Thread(ticket, "1号窗口").start();
      new Thread(ticket, "2号窗口").start();
      new Thread(ticket, "3号窗口").start();
   }
}
 
class Ticket implements Runnable{
   private int tick = 100;
   private Lock lock = new ReentrantLock();
 
   @Override
   public void run() {
      while(true){
         lock.lock(); //上锁
         try{
            if(tick > 0){
               System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
            }
         }finally{
            lock.unlock(); //释放锁
         }
      }
   }
}

虚假唤醒问题

7、Condition 控制线程通信

• 在 Condition 对象中，与 wait、 notify 和 notifyAll 方法对应的分别是await、 signal 和 signalAll。
• Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例，请使用其 newCondition() 方法。

private Condition condition = lock.newCondition();
condition.await();
condition.signal();

8、ReadWriteLock 读写锁

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

class ReadWriteLock1 {
    private int num = 0;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    
    //读
    public void get() {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + ":" + num);
        } finally {
            lock.readLock().unlock();
        }
    }
 
    //写
    public void set(int num) {
        lock.writeLock().lock();
        try {
            this.num = num;
            System.out.println(Thread.currentThread().getName());
        } finally {
            lock.writeLock().unlock();
        }
    }
}

9、线程八锁

1. 两个同步方法，两个线程，标准打印                                        //one two
2. 新增Thread.sleep()给getOne()                                              //one two
3. 新增非同步普通方法getThree()                                              //three one two
4. 两个普通同步方法，两个number对象                                    //two one
5. 修改getOne()为静态同步方法                                                //two one
6. 修改两个方法均为静态同步方法                                              //two one
7. 一个静态同步方法，一个非静态同步方法，两个number对象   //two one
8. 两个静态同步方法，两个number对象                                     //one two

锁机制：

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

10、线程池

• JDK 5.0起提供了线程池相关API： ExecutorService 和 Executors
• ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
• <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
• void shutdown() ：关闭连接池
• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
• Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
• Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
• Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行