JUC 是值 java.util.current 包，现在我们要学习这些包中的一些常用的类。

Callable接口

Callable 接口与Runnable接口一样，都是用来包装任务的，只不过Callable接口有泛型参数且其方法有返回值，我们下面就来演示Callable接口的使用。

代码演示：

public class Test {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception { // 这里面是任务与run方法类似
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
                return count;
            }
        };

        // 将任务进一步分装起来
        FutureTask<Integer> task = new FutureTask<>(callable);

        // 再将任务给到Thread
        Thread t = new Thread(task);
        t.start();
        t.join();

        System.out.println("count: "+ count);
    }
}

下面是lambda表达式的写法：

public class Test {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        // 使用lambda表达式代替匿名内部类
        FutureTask<Integer> task = new FutureTask<>(()->{
            for (int i = 0; i < 10000; i++) {
                count++;
            }
            return count;
        });

        Thread t = new Thread(task);
        t.start();
        t.join();

        System.out.println("count: "+count);
    }
}

上面是我们手动使 main线程阻塞等待 t线程执行完毕，我们还可以使用 FutureTask 中的get方法，从而去被动阻塞 main线程。

public class Test {
    private static Object locker = new Object();
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<Integer> task = new FutureTask<>(()->{
           int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        });

        Thread t = new Thread(task);
        t.start();
        // 在调用get方法时，得到的是call方法的返回值，即主线程会阻塞等待t线程执行完call方法
        System.out.println(task.get());
    }
}

总结：Callable 接口也是函数式接口，通过 call 方法来完成任务，最终的任务需要被 FutureTask进一步分装，从而给到Thread。

ReentrantLock

ReentrantLock是可重入互斥锁，和 synchronized 定位类似，都是用来实现互斥效果，保证线程安全。但是ReentrantLock 是Java标准库提供的一个类，而不是关键字。

ReentrantLock 有三种方法：

1、lock()：加锁，如果获取不到锁就会一直等待，也就是死等。

2、tryLock(超时时间，时间级别)：加锁，如果在超时时间之内没有获取到锁，也是一直等待，但如果超出了超时时间的话，就会放弃等待。

3、unlock()：解锁。

代码演示：

1、lock—unlock方法的使用：

public class Test {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                reentrantLock.lock();
                count++;
                reentrantLock.unlock();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                reentrantLock.lock();
                count++;
                reentrantLock.unlock();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count: "+count);
    }
}

 2、tryLock方法的使用：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentranLock = new ReentrantLock();
        Thread t = new Thread(()->{
            try {
                reentranLock.lock();
                System.out.println("t线程开始");
                Thread.sleep(3000);
                System.out.println("t线程结束");
                reentranLock.unlock();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t.start();
        Thread.sleep(1000); // 确保t线程先加锁成功
        // 等待1s之后，就会不等了
        boolean state = reentranLock.tryLock(1000, TimeUnit.MILLISECONDS);
        if (state) {
            System.out.println("main线程成功获取锁");
            reentranLock.unlock();
        } else {
            System.out.println("main线程获取锁失败");
        }
        System.out.println("main线程结束");
    }
}

运行结果：

tryLock还有一个重载的方法，是不带有任何参数的，其含义是：尝试去获取锁时，如果锁处于空闲状态就返回true，否则就返回false。这个是不会去等待的。 

synchronized 与 ReentrantLock的区别 

1、synchronized 是关键字，其底层的实现是JVM内部通过C++实现的，而 ReentrantLock 是标准库中的类，是用Java实现的。

2、synchronized 是通过代码块来控制加锁与解锁的，而 ReentrantLock是通过lock 与 unlock 方法来控制加锁与解锁的，且一定要记得及时去解锁。

3、ReentrantLock 除了普通的加锁、解锁操作之外，还提供了 tryLock方法。不带参数的版本，就是直接去判断这个锁的状态，如果没有线程持有的话，就会进行加锁操作，然后返回true；反之，则会直接返回false，不会进行等待。而带有参数的版本就会等待对应的超时时间去尝试获取锁，如果在超时时间之外了，就会直接返回false。

4、ReentrantLock 本身默认是非公平锁，但是其提供了 公平锁的实现方式。

5、ReentrantLock搭配的等待通知机制，是Condition类，相比wait notify来说功能更强大一些，但是使用的方法是类似的。也是需要先加锁，然后再进行使用的。await 方法是可以更精准地唤醒等待的线程。在有多个等待线程的情况下，signal 可以选择唤醒特定的线程，而Object 类的notify方法在唤醒线程时是相对随机的。

代码演示：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 下面的锁就是公平锁，是在参数内部传入一个true即可
        ReentrantLock reentrantLock = new ReentrantLock(true);
        Condition condition = reentrantLock.newCondition();
        Thread t1 = new Thread(()->{
            System.out.println("t线程开始执行");
            reentrantLock.lock();
            try {
                System.out.println("t1线程即将被阻塞");
                condition.await(); // 阻塞线程t1
                System.out.println("t1线程被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            reentrantLock.unlock();
            System.out.println("t线程结束执行");
        });
        t1.start();
        Thread.sleep(1000); // 确保t1线程先加锁成功

        Thread t2 = new Thread(()->{
            System.out.println("t2线程开始执行");
            reentrantLock.lock();
            condition.signal(); // 唤醒正在处于阻塞状态的线程
            reentrantLock.unlock();
            System.out.println("t2线程结束执行");
        });
        t2.start();
        System.out.println("main线程结束");
    }
}

信号量（Semaphore）

信号量主要用来协调进程与线程之间的资源分配。其底层是一个计数器，记录当前资源的可用个数。申请资源，对应的P操作，信号量会减少，释放资源，对应的V操作，信号量会增加。当信号量对应的计数器为0了，此时线程再去申请资源的话，就会线程阻塞。

在Java标准库中，Semaphore 是对应的类。

代码演示：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 通过参数指定“可用资源”的个数
        Semaphore semaphore = new Semaphore(5);
        System.out.println("可用资源的个数："+semaphore.availablePermits());
        // 获取资源
        for (int i = 0; i < 3; i++) {
            System.out.println("正在获取可用资源~");
            // 获取"可用资源"
            semaphore.acquire(); // 也可以传入参数来设定获取的个数，默认1
        }
        System.out.println("剩余可用资源的个数："+semaphore.availablePermits());
        // 释放资源
        for (int i = 0; i < 3; i++) {
            System.out.println("正在释放可用资源~");
            // 释放“可用资源”
            semaphore.release(); // 也可以传入参数来设定释放的个数，默认1
        }
        System.out.println("最终可用资源的个数："+semaphore.availablePermits());
    }
}

运行结果：

注意：当信号量的初始容量为1时，此时就相当于是一把锁。 

CountDownLatch

当一个大的任务被分成多个小任务时，如何知道所有的小任务全部执行完了呢？

1、可以使用 join 的普通等待方法。

2、可以使用计数器来记录当前的完成任务的线程数。

而针对第二种方式，Java标准库中给出了一个类：CountDownLatch。通过构造方法创建出多个任务，当与之对应的线程完成一个任务时，就可以调用 countDown方法来更新计数器的值，最终当计数器的值达到我们的预期时，便可以让主线程继续去执行其它的逻辑了。

代码实现：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        int n = 3;
        CountDownLatch latch = new CountDownLatch(n); // 创建了初始值为n的计数器
        // 模拟下载的线程
        System.out.println("等待下载...");
        for (int i = 0; i < n; i++) {
            new Thread(() -> {
                System.out.println("正在下载...");
                try {
                    // 模拟下载过程
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("下载完成...");
                latch.countDown(); // 更新计数器，计数器--
            }).start();
        }
        // 等待上述任务全部执行完毕，当计数器为0时，任务执行完毕，脱离阻塞。
        // 任务没有执行完成时，主线程会处于阻塞状态
        latch.await();
        System.out.println("下载完成，正在解压...");
        System.out.println("成功解压...");
    }
}

多线程下使用ArrayList、哈希表

普通的ArrayList是没有加锁的，那么在多线程的情境下使用，就会出现线程安全问题，而解决线程安全问题，有三种方法：

1、根据需要自行加锁。

2、无脑将所有的可能会出现线程安全问题的代码全部进行加锁。

3、CopyOnWriteArrayList。

第一二种方式都是采用加锁操作，来确保线程安全。

代码演示：

public class Test {
    private static final Object locker = new Object();
    public static void main(String[] args) throws InterruptedException {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                synchronized (locker) {
                    arrayList.add(i);
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                synchronized (locker) {
                    arrayList.add(i);
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(arrayList.size());
    }
}

上面这种方式就是按需加锁，只在出现线程安全问题的代码部分进行加锁操作，而不是对add这个方法进行无脑的加锁。 

第三种方式，采用了写时拷贝的方法。当线程1在进行"写"操作时，如果线程2来进行"读"操作，这时就让线程2读取原来版本的数据，这样线程1在进行"写"操作时，就不会影响到线程2的"读"操作，也就不会造成线程不安全，那么也就没必要进行加锁操作，从而导致的程序运行效率降低。

缺陷：

1、当数据量过大时，拷贝的成本也就高了很多，这样最终的效率可能还不如加锁的操作呢。

2、当多个线程进行修改操作时，就不能保证线程安全了。因为多个线程进行修改操作，就会拷贝出多份数据，最后怎么合并呢？可能会出现覆盖的问题，其次这是并发执行，因此没发确定顺序的先后，因此就导致了最终数据的不确定性。 

普通的哈希表也是有线程安全问题的。Java标准库中，给我们提供了两个类：Hashtable、ConcurrentHashMap。前者是对整个哈希表进行加锁操作，而后者是对哈希表的每个元素进行加锁操作。

不管是Java标准库中的哈希表，还是我们之前手动实现的哈希表，针对哈希冲突的问题，我们采用的都是数组+链表的方式，而不是去使用线性探测。而对于数组+链表这种方式，只有在同一个链表上面进行修改操作时，才会涉及线程安全问题，因此没必要对整个数组进行加锁。

ConcurrentHashMap相对于Hashtable有以下三个优化的地方：

1、针对数组的加锁操作，变成了对链表进行加锁操作；

2、使用原子类对size进行维护；

3、对于哈希扩容的问题，是分多次进行的，这样每一次所消耗的时间就会比较少。例如，准备扩容时，就可以标记一下，等到下一次在进行put操作时，重新将这个元素所在原链表进行新的哈希映射，当每一个链表都修改完毕时，哈希表的扩容操作也就完成了。

好啦！本期 初始JavaEE篇——多线程（8）：JUC的组件 的学习之旅就到此结束啦！我们下一期再一起学习吧！