第1章 并发编程的挑战

　　并发编程的目的是为了让程序运行的更快，但是并不是启动更多的线程就能让程序最大限度的并发执行。会面临非常多的挑战，比如上下文切换的问题、死锁的问题，以及软件硬件资源的问题等。

1.1 上下文切换

　　即使是单核处理器也支持多线程执行代码，CPU通过分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停的切换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒（ms）。在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到在加载的过程就是一次上下文切换。

　　1.1.1 多线程一定快吗

package com.example.demo.currency;

public class ConcurrencyTest {
    private static final long count = 100001;
    
    private static void concurrency() throws Exception{
        long start = System.currentTimeMillis();
        Thread thread = new Thread(new Runnable() {
            
            @Override
            public void run() {
                int a = 0;
                for(long i=0;i<count;i++) {
                    a +=5;
                }
            }
        });
        thread.start();
        int b = 0;
        for(long i=0;i<count;i++) {
            b--;
        }
        thread.join();
        long time = System.currentTimeMillis() - start;
        System.out.println("currency :" + time +"ms,b="+b);
    }
    
    private static void serial() {
        long start = System.currentTimeMillis();
        int a = 0;
        for(long i=0;i<count;i++) {
            a +=5;
        }
        int b = 0;
        for(long i=0;i<count;i++) {
            b--;
        }
        long time = System.currentTimeMillis() - start;
        System.out.println("serial :"+ time +"ms,b="+b);
    }
    
    public static void main(String[] args) throws Exception{
        concurrency();
        serial();
    }
}

　　运行次数越多，并发执行运行速度越快

　　1.1.2 测试上下文切换次数和时长

　　　　Lmbench3 查看时长nag

　　　　vmstat可以测量上下文切换的次数

　　1.1.3如何减少上下文切换

　　　　减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程

　　　　　　*无锁并发编程。多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据。

　　　　　　*CAS算法。Java的Atomic包使用CAS算法来更新数据，而不需要加锁

　　　　　　*使用最少线程。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样就会造成大量的线程都处于等待状态。

　　　　　　*协程：在单线程里使用多任务的调度，并在单线程里维持多个任务间的切换

1.2死锁

　　我们先来看一段代码，这段代码会引起死锁，使线程t1和线程t2互相等待对方释放锁。

　　　　

package com.example.demo.currency;

public class DeadLockDemo {
    private static String A = "A";
    private static String B = "B";
    
    private void deadLock() {
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized (A) {
                    try {
                        Thread.currentThread().sleep(2000);
                    }catch (Exception e) {
                        e.printStackTrace();
                    }
                    synchronized (B) {
                        System.out.println("1");
                    }
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized (B) {
                    synchronized (A) {
                        System.out.println("2");
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
    
    public static void main(String[] args) {
        new DeadLockDemo().deadLock();
    }
}

　　1.3 资源限制的挑战

　　　　集群并行来提高运行速度