JUC 基本操作

一、JUC-TimeUnit枚举

TimeUnit是  java.util.concurrent 中的一个枚举类（时间单元类）。一般让进行控制线程睡眠时使用。

TimeUnit提供了可读性更好的线程暂停操作，通常用来替换Thread.sleep()，相比 Thread.sleep()方法的一个好处就是 TimeUnit可以设置时间单位。

这个类支持有：日（DAYS）、时（HOURS）、分（MINUTS）、秒（SECONDS）、毫秒（MILLISECONDS）、微秒（MICROSECONDS）、纳秒（NANOSECONDS）。

    

1、实例：进行休眠控制，休眠2秒

    使用Thread.sleep() 方法处理

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("[sleep start]"+System.currentTimeMillis());
                try {
                    Thread.sleep(2*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("[sleep end]"+System.currentTimeMillis());
            }
        }).start();
    }

    直接使用TimeUnit类来处理

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("[sleep start]"+System.currentTimeMillis());
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("[sleep end]"+System.currentTimeMillis());
            }
        }).start();
    }

2、时间单位的转换

在 TimeUnit类中最为重要的特点是可以方便的进行各种时间单位的转换，它提供了一个convert()方法

实例：1小时转换为秒数

    public static void main(String[] args) {
        long sec = TimeUnit.SECONDS.convert(1, TimeUnit.HOURS);
        System.out.println("1小时转换为秒数：" + sec);

        long minutes = TimeUnit.MINUTES.convert(sec, TimeUnit.SECONDS);
        System.out.println(sec + "秒有转换为分钟：" + minutes);
    }

二、JUC-Atomic Variables（原子变量）

 简单使用：volatile关键字与内存可见性

三、JUC-Concurrent Collections（并发容器）

JUC里的同步容器类

1、java 基础数据集合容器中

线程安全与非线程安全的对象如下

Collection  |--List |--ArrayList
            |       |--LinkList
            |       |--Vector -->线程安全
            |
            |
            | --Set |--TreeSet
                    |--HashSet
Map |--TreeMap
    |--HashMap
    |--HashTable -->线程安全

StringBuffer  -->线程安全
StringBulider -->非线程安全

解决这些非线程安全的集合的线程安全

通过使用的 Collections.synchronizedXXX()方法来转换。HashMap的话可以直接使用HashTable转换

    

（1）List用线程安全对象处理，map同理

public class CollectionDemo {

    private static Vector list = new Vector();
//    private static List list = new ArrayList();
//    private static List list = Collections.synchronizedList(new ArrayList());

    public static void main(String[] args){
        //让50个线程去执行
        for (int i = 0; i < 50; i++) {
            new MyThread().start();
        }
    }

    private static class MyThread extends Thread{
        @Override
        public void run() {            
            for (int i = 0; i < 100; i++) {
                list.add(i);
            }
            System.out.println("集合大小：--->"+list.size());//预期的集合大小应该是50x100=5000
        }
    }

}

（2）读写处理

public class CollectionDemo {

    private static List list = Collections.synchronizedList(new ArrayList());

    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new MyThread().start();
        }
    }

    private static class MyThread extends Thread{
        @Override
        public void run() {
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            list.add("add" + Thread.currentThread().getName());
        }
    }

}

    

注意：上面的解决方法，一是程序效率低；二是在复合操作的时候会报并发修改异常（ConcurrentModificationException）。  

2、JUC 解决非线程安全的集合类

JUC里面提供了一系列同步容器类用来解决非线程安全的集合类，我们只需要在多线程并发编程中，用这些同步容器类类替换掉原来的HashMap，ArrayList，HashSet集合，就可以了保证即是线程安全的，比使用 Collections.synchronizedXXX()的效率高。

HashMap -- ConcurrentHashMap

TreeMap -- ConcurrentSkipListMap

ArrayList -- CopyOnWriteArrayList

ArraySet -- CopyOnWriteArraySet等等

CopyOnWriteArrayList和CopyOnWriteArraySet 每次存入要新建一个存储结构，写操作效率低比Vector都低,浪费空间,用于写得少，读得多。

public class CollectionDemo {

    private static CopyOnWriteArrayList list = new CopyOnWriteArrayList();

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            new MyThread().start();
        }
    }

    private static class MyThread extends Thread{
        @Override
        public void run() {
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
                System.out.println(Thread.currentThread().getName() + "==" + iterator.next());
            }
            list.add("add" + Thread.currentThread().getName());
        }
    }

}

    

四、JUC-Synchronizers（同步器）

JUC-Synchronizers（同步器），有三个类，用于同步一批线程的行为，分别是：

• CountDownLatch
• Semaphore
• CyclicBarrier

1、CountDownLatch类 - 倒计时锁

CountDownLatch是一个倒计时锁/计数器闭锁（俗称发令枪），它允许一个或多个线程等待倒计时为0的时候才执行。

所谓的倒计时：其实就是一个 int类型的变量，在初始化 CountDownLatch的时候会给他一个初始值（程序员定的）；在多线程工作的时候可以通过countDown()方法来对计数器-1（计数器的操作是原子操作）；当等于0的时候线程则会解阻塞运行。

例如：为了让主线程等待工作线程执行完成，主线程调用await操作让主线程阻塞，当工作线程完成初始化过程之后，每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

public class CountDownLatchDemo {

    public static void main(String[] args) {
        // 创建 CountDownLatch， 3个线程任务
        CountDownLatch countDownLatch = new CountDownLatch(3);
        LatchDemo latchDemo = new LatchDemo(countDownLatch);
        for (int i = 0; i < 3; i++) {
            new Thread(latchDemo).start();
        }

        try {
            // 主线程执行await方法，进行等待，直到计数器的值为0时继续向下执行
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程运行完成");

    }

    public static class LatchDemo implements Runnable{
        private CountDownLatch countDownLatch = null;

        public LatchDemo(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                for (int i = 0; i