Java多线程与并发（三）

• Condition等待和唤醒

在我们的并行程序中，避免不了某些写成要预先规定好的顺序执行，例如：先新增后修改，先买后卖，先进后出，对于这些场景，使用JUC的Conditon对象再合适不过了。

JUC中提供了Condition对象，用于让指定线程等待与唤醒，按预期顺序执行。它必须和ReentrantLock重入锁配合使用

Condition用于代替wait()/notify()方法
wait和notify是属于Object的，可以对线程唤醒（notify只能随机唤醒等待的线程，而Condition可以唤醒指定线程，这有利于更好的控制并发程序）
Condition核心方法：
await()：阻塞当前线程，直到signal唤醒
signal()：唤醒被await的线程，从中断处继续执行
signalAll()：唤醒所有被await阻塞的线程（不太常用）

通过使用ReentrantLock和Condition的使用让线程有顺序的执行（有规划的、等待、唤醒的过程）

代码案例：

public class ConditionSample {
    public static void main(String[] args) {
        final ReentrantLock lock = new ReentrantLock();//Condition必须配合ReentrantLock来使用
        final Condition c1 = lock.newCondition();//创建Condition
        final Condition c2 = lock.newCondition();
        final Condition c3 = lock.newCondition();
        new Thread(new Runnable() {
            public void run() {
                lock.lock();//加锁
                try {
                    c1.await();//阻塞当前线程，只有调用c1.signal的时候，线程继续激活执行
                    Thread.sleep(1000);
                    System.out.println("粒粒皆幸苦");
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }finally{
                    lock.unlock();//释放
                }
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {

                lock.lock();//加锁
                try {
                    c2.await();//阻塞当前线程，只有调用c1.signal的时候，线程继续激活执行
                    Thread.sleep(1000);
                    System.out.println("谁知盘中餐");
                    c1.signal();//线程t1唤醒继续执行
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }finally{
                    lock.unlock();//释放
                }       
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {


                lock.lock();//加锁
                try {
                    c3.await();//阻塞当前线程，只有调用c1.signal的时候，线程继续激活执行
                    Thread.sleep(1000);
                    System.out.println("汗滴禾下土");
                    c2.signal();//线程t2唤醒继续执行
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }finally{
                    lock.unlock();//释放
                }

            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                lock.lock();//加锁
                try {
                    Thread.sleep(1000);
                    System.out.println("锄禾日当午");
                    c3.signal();//t3线程继续执行
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }finally{
                    lock.unlock();//释放
                }       
            }
        }).start();
    }
}

• JUC之Callable和Future
  Callable是一个接口，它和Runnable一样代表着任务，区别在于Callable有返回值并且可以抛出异常
  Future也是一个借口，它用于异步计算的结果，提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果，接受Callable返回的方法
  案例：输出1000以内的质数

public class FutureCallableSample {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        //创建线程池
        for(int i = 2;i<=10000 ;i++){
            Computer c = new Computer();
            c.setNum(i);

            //Future是对用于计算的线程的监听，因为计算是在其它线程中进行的，所以这个返回结果是异步的

            Future  fu = threadPool.submit(c);//将c对象提交给线程池，如果有空闲线程立即执行call方法
            try {
                Boolean result = fu.get();//用于获取返回值，如果线程内部的call没有计算完毕，则进入等待状态，直到计算完成
                if(result){
                    System.out.println(c.getNum());
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        threadPool.shutdown();
    }

}

• JUC之并发容器

如何保证既能线程安全，又可以有一定效率
线程安全—-并发容器
ArrayList —-CopyOnWriteArrayList —写复制列表
HashSet —–CopyOnWriteArraySet —写复制集合
HashMap —-ConcurrentHashMap —分段锁映射

public class CopyOnWriteArrayListSample {
    public static void main(String[] args) {
        List list = new ArrayList();
        for(int i =0; i<1000;i++){
            list.add(i);
        }
        Iterator it = list.iterator();
        while(it.hasNext()){
            Integer i = (Integer)it.next();
            list.remove(i);
        }
        System.out.println(list);
    }
}

代码会报错：

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at com.wanghaoxin.threadpool.CopyOnWriteArrayListSample.main(CopyOnWriteArrayListSample.java:15)

对于ArrayList默认采用连续存储，但是会有并发问题，边读取边删除产生异常

CopyOnWriteArrayList采用即可解决这个问题：

public class CopyOnWriteArrayListSample {
    public static void main(String[] args) {
/*      List list = new ArrayList();
        for(int i =0; i<1000;i++){
            list.add(i);
        }
        Iterator it = list.iterator();
        while(it.hasNext()){
            Integer i = (Integer)it.next();
            list.remove(i);
        }
        System.out.println(list);*/
        //写复制列表
        List list = new CopyOnWriteArrayList();
        for(int i =0; i<1000;i++){
            list.add(i);
        }
        Iterator it = list.iterator();
        while(it.hasNext()){
            Integer i = (Integer)it.next();
            list.remove(i);
        }
        System.out.println(list);
    }
}

写复制列表：CopyOnWriteArrayList并发原理：
它通过副本解决并发问题
多个线程各执一份副本，采用副本的方式，再复制的过程中，不同线程是同步的
查看源码得知：采用可重入锁

    public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            int numMoved = len - index;
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

ConcurrentHashMap
Segment——分段锁，提高了批量同步的性能
HashMap线程不安全的，输出值总是小于5000，但是如果代码中修改为HashTable则输出值为5000（HashTable中所有方法都是synchronized 只允许同一时间同一线程修改）
为了解决效率低下的问题，产生了ConcurrentHashMap，输出值始终为5000—表示线程安全

public class ConcurrentHashMapSample {

    private static int user = 100;//同时模拟的并发用户访问数量 --为1的话看不出来效果
    //private static int user = 10;
    private static int dowloadCounts = 5000;//用户的真实下载数
    private static HashMap count= new HashMap();//计数器

    public static void main(String[] args) {
        //调度器，jdk1.5之后引入current对于并发的支持

        ExecutorService executor = Executors.newCachedThreadPool();
        //信号量 ，用于模拟并发用户数
        final Semaphore semaphore = new Semaphore(user);
        for(int i =0;ifinal int index = i;
            //通过多线程模拟多个用户访问的下载次数
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try{
                        semaphore.acquire();
                        count.put(index, index);
                        semaphore.release();
                    }catch(Exception e){
                        e.printStackTrace();
                    }

                }
            });
        }
        try {
            //延迟主线程结束--让for循环中代码执行完毕
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count.size());
    }
}

ConcurrentHashMap实现原理：
采用分段锁Segment机制
HashTable：所有操作方法都是同步的，其他线程必须等待
这样效率很低

ConcurrentHashMap把区域分为一个个的很小区域，segment，不同线程访问不同的数据，只要不是同一段内都可以操作，但是如果操作的数据在同一个段内，这样需要线程排队

这样效率很快，（极限）16倍，把原来的存储空间进行分段加锁处理，段的长度都是2的n次方

• *JUC之Atomic余CAS算法（乐观锁）
  原子性：是指一个操作或多个操作要么全部执行，且执行的过程不会被任何因素打断，要么就都不执行

Atomic包是java.util.concurrent下的另一个专门为线程安全设计的java包，包含多个原子操作类
Atomic包：

代码：

public class AtomicIntegerSample {


    private static int user = 10;//同时模拟的并发用户访问数量
    //private static int user = 10;
    private static int dowloadCounts = 5000;//用户的真实下载数
    private static AtomicInteger count= new AtomicInteger(0);

    public static void main(String[] args) {
        //调度器，jdk1.5之后引入current对于并发的支持

        ExecutorService executor = Executors.newCachedThreadPool();
        //信号量 ，用于模拟并发用户数
        final Semaphore semaphore = new Semaphore(user);
        for(int i =0;i//通过多线程模拟多个用户访问的下载次数
            executor.execute(new Runnable() {

                @Override
                public void run() {
                    try{
                        semaphore.acquire();
                        add();
                        semaphore.release();
                    }catch(Exception e){
                        e.printStackTrace();
                    }

                }
            });
        }
        try {
            //延迟主线程结束--让for循环中代码执行完毕
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
/*  private synchronized static void add(){
        count++;
    }*/
    private  static void add(){
        count.getAndIncrement();//count++
    }
    //此处并没有用synchronized和锁机制


}

CAS算法：
锁是用来做并发的最简单的机制，当然其代价也是很高的，独占锁是一种悲观锁，synchronized就是一种独占锁，它假设最坏的情况，并且只有在确保其它线程不会造成干扰的情况下执行，会导致所有需要锁的线程刮起，等待持有锁的线程释放锁

所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。
其中CAS(比较与交换 Compare And Swap )，是一种有名的无锁算法

比较的是期望值与实际操作的结果

Atomic的应用场景：
虽然基于CAS的线程安全机制很好很搞笑，但是要说的是，并非所有线程安全都可以用这样的方法来实现，这只适合于一些锁粒度比较小型：例如计数器这样的需求用起来才更有效果，否则也不会有锁的存在了

对于大量数据操作反而会损耗性能，因为做了很多次

• 总结