Java并发篇一

CopyOnWriteArrayList

package com.kuang.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

// 使用普通的ArrayList并发时会出现以下异常
//java.util.ConcurrentModificationException并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //List list=new ArrayList<>();
        // 解决方案
        // 一：List list=new Vector<>();
        // 二：List list= Collections.synchronizedList(new ArrayList<>());
        // 三：List list=new CopyOnWriteArrayList<>();
        // CopyOnWrite 写入时复制
        // 在写入的时候避免覆盖，出现数据问题
        List list=new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }

    }
}

多个线程调用的时候，读取时是固定的，写入时可能会发生覆盖，所以计算机程序设计领域优化的策略是使用CopyOnWriteArrayList 

CopyOnWriteArraySet

package com.kuang.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

// 同理可证
// java.util.ConcurrentModificationException
public class SetTest {
    public static void main(String[] args) {
        //Set set=new HashSet<>();
        //Set set= Collections.synchronizedSet(new HashSet<>());
        Set set=new CopyOnWriteArraySet<>();

        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

HashSet底层是HashMap 

public HashSet() {
        map = new HashMap<>();
    }
// map中key不可重复的
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
private static final Object PRESENT = new Object();//不变的值

ConcurrentHashMap

package com.kuang.unsafe;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

//java.util.ConcurrentModificationException
public class MapTest {
    public static void main(String[] args) {
        //HashMap map = new HashMap<>();
        Map map = new ConcurrentHashMap<>();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,3));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

Callable(简单)与Runnable相比

• 可以有返回值
• 可以抛出异常
• 方法不同，call() 

走近Callable 

Runnable和Callable实现类有：FutureTask 

细节：有缓存、结果可能需要等待，会阻塞 

new Thread(new Runnable(){
    @Override
    public void run(){
        System.out.println("run()");
    }
}.start();

new Thread(new FutureTask()).start();
new Thread(new FutureTask(Callable)).start();

package com.kuang.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) {
        /*new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();*/
        MyThread thread=new MyThread();
        FutureTask task = new FutureTask<>(thread);//适配类
        new Thread(task,"A").start();
        new Thread(task,"B").start();
        try {
            // get()方法可能会产生阻塞，把它放到最后
            Integer res = task.get();
            // 使用异步通信来处理
            System.out.println(res);//123
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class MyThread implements Callable{

    @Override
    public Integer call() throws Exception {
        System.out.println("call()");//会打印1个
        // 耗时操作
        return 123;
    }
}

常用的辅助类

减法计数器CountDownLatch:指定线程执行完毕再执行操作

package com.kuang.add;

import java.util.concurrent.CountDownLatch;
// 计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        // 6个人要出去才能关门
        // 要执行的任务再使用
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"go out");
                countDownLatch.countDown();//-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();// 等待计数器归0，再向下执行
        System.out.println("close door");
    }
}

原理：每次线程调用countDown()方法计数器就减1，当减到0时，await()方法就会被唤醒，继续向下执行

加法计数器CyclicBarrier ：执行达到指定线程数再执行操作 Lambda表达式无法访问外部变量i

package com.kuang.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
// 集齐七龙珠召唤神龙
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙成功");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"集齐第"+temp+"个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

信号量Semaphore：多个共享资源互斥使用（并发限流，控制最大线程数）

package com.kuang.add;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量：停车位 3
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "获得车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

原理：semaphore.acquire();获得，假设已经满了等待，等待被释放为止

semaphore.release();释放，将当前信号量释放+1，唤醒等待的线程

ReadWriteLock读写锁

package com.kuang.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 *  独占锁（写锁）：一次只被一个线程占有
 *  共享锁（读锁）：多个线程可以同时占有
 *  读-读 可以共存
 *  写-写 不能共存
 *  读-写 不能共存
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock cacheLock = new MyCacheLock();
        // 写入操作
        for (int i = 1; i <=5; i++) {
            final int temp=i;
            new Thread(()->{
                cacheLock.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        // 读取操作
        for (int i = 1; i <=5; i++) {
            final int temp=i;
            new Thread(()->{
                cacheLock.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

class MyCacheLock{
    private volatile Map map=new HashMap<>();
    private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.readLock().unlock();
        }
    }

}

阻塞队列BlockingQueue 非阻塞队列AbstractQueue 双端队列Deque

/**
     * 抛出异常
     */
    public static void test1(){
        ArrayBlockingQueue