并发编程的挑战

    并发编程的目的是为了让程序运行的更快，可是并非启动更多的线程就能让程序最大限度的并发执行。在进行并发编程时，若是但愿经过多线程执行任务让程序运行的更快，会面临很是多的挑战，如上下文切换问题、死锁问题、以及受限于硬件和软件的资源限制问题。

一、1上下文切换

    即便是单核处理器也支持多线程执行代码，cpu经过给每一个线程分配cpu时间片来实现这个机制。时间片是cpu分配给各个线程的执行时间，由于时间片很是短，因此cpu经过不停切换线程执行，让咱们感到多个线程是同时执行的，时间片通常是几十毫秒。

    cpu经过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。可是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，能够加载这个任务的状态，因此任务从保存到再加载的过程就是一次上下文切换。

一、一、1多线程必定快吗

    下面的代码演示串行和并发执行并累加操做时间，请分析：并发执行必定比串行执行快吗？

/**
 * 并发和串行执行测试
 */
 public class ConcurrencyTest {
    /** 执行次数 */
    private static final long count = 100000l;
    public static void main(String[] args) throws InterruptedException {
        // 并发计算
        concurrency();
        // 单线程计算
        serial();
    }
    private static void concurrency() throws InterruptedException {
        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;
                }
                System.out.println("concurrency :a=" + a);
            }
        });
        thread.start();
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        thread.join();
        long time = System.currentTimeMillis() - start;
        System.out.println("concurrency :" + 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 + ",a=" + a);
    }
}

 运行上述程序发现，当并发执行累加操做不超过百万时，速度比串行执行累加操做要慢。那么为何会慢呢，这是由于线程有建立和上下文切换的开销。

一、一、2如何减小上下文切换

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

无锁并发编程：多线程竞争锁时，会引起上下文切换，因此多线程处理数据时，能够用一些办法来避免使用锁，如将数据的ID按hash算法取模分段，不一样的线程处理不一样段的数据。

CAS算法：java并发包中的Atomic使用CAS算法来更新数据，而不须要加锁。

使用最少线程：避免建立不须要的线程，好比任务不多，可是建立了不少线程来处理，这样会形成大量线程都处于等待状态。

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

 

一、2死锁

    锁时很是有用的工具，运用场景很是多，但同时也会带来一些困扰，那就是可能引发死锁问题，一旦产生死锁，会形成系统功能不可用。下面这段代码会引发死锁，是线程t1和线程t2互相等待对方释放锁。

/**
 * 死锁例子
 */
public class DeadLockDemo {

    /** A锁 */
    private static String A = "A";
    /** B锁 */
    private static String B = "B";

    public static void main(String[] args) {
        new DeadLockDemo().deadLock();
    }

    private void deadLock() {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (A) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException 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();
    }
}

  一旦出现死锁，业务是可感知的，由于不能继续提供服务了，只能dump线程查看到底哪一个线程出现了问题。

  避免死锁的几个常见方法：

避免一个线程同时得到多个锁

避免一个线程在锁内同时占用多个资源，尽可能保证每一个资源只占用一个资源

尝试使用定时锁，使用Lock.tryLock(time)来替代使用内部锁机制

对于数据库锁，加锁和解锁必须在一个数据库链接里，不然会出现解锁失败的状况

一、3资源限制的挑战