Java并发编程的艺术（一）——并发编程的注意问题

• 并发编程是为了使程序运行得更快，但是，不是启动更多得线程就能最大限度地执行并发，也不是线程更多就能使得程序运行得更快，而且并发编程更容易产生错误，如果要高效且正确地执行并发，就需要注意这三种问题
  1. 上下文切换
  2. 死锁
  3. 资源限制

上下文切换

线程运行机制

1. 一个CPU同时只能运行一个线程；
2. 操作系统给每条分配时间片；
3. 拿到时间片的线程就可以方法CPU上运行；
4. 当前线程用完自己的时间后，操作系统会剥夺其CPU的使用权，然后换下一个线程。

什么是上下文切换

当前任务时间片结束需要切换到下一个任务的时候，就会保存当前的任务的状态，包括各类寄存器数据，以便下次又切换回这个任务时，读取状态信息，就直接可以执行任务。任务从保存到加载，就是一次上下文切换。

上下文切换的开销

每次进程线程切换的时候，都需要保存上下文，而保存线程的上下文信息就要消耗CPU，如果频繁地进行线程切换，就会增加CPU在上下文切换中的开销，降低任务效率。

如何减少上下文切换

• 无锁并发编程：多线程的竞争锁会引起上下文切换，所以，可以利用一些方法避免使用锁，例如将数据的ID进行HASH取模，不同线程处理不同段的数据。
• CAS算法：这也是属于无锁的多线程资源竞争的一种方法，如果有多个线程需要修改共享变量，那么就必须控制线程的执行顺序，否则会造成数据错误。可以给任务加锁，保证任务的原子性和可见性，但是会造成阻塞，从而发生上下文切换；可以用过CAS算法，当需要更新变量的时候，利用CAS算法，就不会阻塞线程。
• 使用最少的线程数：线程多了，自然会有更多的上下文切换，去掉不必要的线程。
• 协程：可以实现单线程中多个任务的调度和切换。

进程和协程
协程是一种用户态的轻量级线程，协程的调度完全由用户控制。从技术的角度来说，“协程就是你可以暂停执行的函数”。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。
线程是指进程内的一个执行单元,也是进程内的可调度实体。线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。
协程与线程的区别:

1. 一个线程可以多个协程，一个进程也可以单独拥有多个协程。
2. 线程进程都是同步机制，而协程则是异步。
3. 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。
   4）线程是抢占式，而协程是非抢占式的，所以需要用户自己释放使用权来切换到其他协程，因此同一时间其实只有一个协程拥有运行权，相当于单线程的能力。
   5）协程并不是取代线程, 而且抽象于线程之上, 线程是被分割的CPU资源, 协程是组织好的代码流程, 协程需要线程来承载运行, 线程是协程的资源, 但协程不会直接使用线程, 协程直接利用的是执行器(Interceptor), 执行器可以关联任意线程或线程池, 可以使当前线程, UI线程, 或新建新程.。
   6）线程是协程的资源。协程通过Interceptor来间接使用线程这个资源。

死锁

怎么样会死锁

当多个线程相互占有对方线程的正在等待的资源时，而大家都不放弃资源，就会造成死锁。

死锁示例

class DeadLock {
    // 锁A 
    private Object lockA;
    // 锁B
    private Object lockB;

    // 第一条线程
    Thread t1 = new Thread(new Runnable(){
        void run () {
            synchronized (lockA) {
                Thread.sleep(1000);
                synchronized (lockB) {
                    System.out.println("Thread1");
                }
            }
        }
    }).start();

    // 第二条线程
    Thread t2 = new Thread(new Runnable(){
        void run () {
            synchronized (lockB) {
                Thread.sleep(1000);
                synchronized (lockA) {
                    System.out.println("Thread2");
                }
            }
        }
    }).start();
}

在上面的代码中，占有A的线程又想要占有B，占有B的线程又想要占有A，这样谁都不放开自己的资源，又再等待对方占有的资源，就会造成无尽的阻塞。

如果避免死锁

• 避免一个线程同时获取多个锁。
• 尽量保证每个锁内只占用一个资源。
• 使用定时锁，当超时就不在阻塞等待。
• 对于数据库，加锁和解锁在一个数据库连接里。

计算机资源限制

什么是资源限制

在并发编程时，程序的执行速度受限制于计算机的硬件或软件资源。例如程序写了想要十个数据库连接，但是现在只有五个，那么执行效率最多只有五个。

有哪些资源

• 硬件：带宽、硬盘读写速度、CPU处理速度。
• 软件：数据库连接数和socket连接数等。

资源限制带来的问题

如果当前资源允许少量线程高效率执行的时候，盲目增加线程，不仅不会提高执行效率，反而会造成上下文切换和资源调度的时间变长，降低系统效率。

如果解决资源限制的问题

• 对于硬件问题，买更多的更强的机器，搭建集群并发。
• 对于软件问题：使用资源池将资源复用，例如数据库连接池。

在资源限制的情况下并发

不把并发程度写死，而是根据资源的状态，动态调整程序的并发度。