java并发编程的艺术（1）并发编程的挑战

在常见的多线程编程里面，我们总是希望创建多个线程来让程序的运行速度更加快速。但是，并不是启动更加多的线程就可以让程序运行地更加快速了。例如说当出现了上下文切换的情况和死锁的情况。因此下边小编会编写一些典型的案例来说明并发和串行的效率区别。

上下文切换：
使是单核处理器也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停地切换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒（ms）。

多线程执行案例：

package 并发编程01.串行和并发的效率比较;

public class ConcurrencyTest {
    private static final long count=100000000l;
    public static void concurrency() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread thread= new Thread(new Runnable(){
                @Override
                public void run() {
                    for(int i=0;i<count;i++){
                    }
                }
            });
        thread.start();
        long end=System.currentTimeMillis();
        thread.join();
        System.out.println("并发消耗时间为："+(end-begin));
    }
    public static void serial(){
        long begin=System.currentTimeMillis();
        for(int i=0;i<count;i++){
        }
        long end=System.currentTimeMillis();
        System.out.println("串行消耗时间为："+(end-begin));
    }

    public static void main(String[] args) throws InterruptedException {
        concurrency();
        serial();
    }

}

在经过多次调整的比较下，我得出了以下数据：

---

循环10次： 并发： 1ms 串行：0ms
循环100次： 并发： 1ms 串行：0ms
循环1000次： 并发： 1ms 串行：0ms
循环10000次： 并发： 1ms 串行：1ms
循环100000次： 并发： 1ms 串行：3ms
循环1000000次： 并发： 1ms 串行：4ms
循环10000000次： 并发： 1ms 串行：12ms
循环100000000次： 并发： 1ms 串行：63ms

---

通过这一组数据，我们可以发现，当数据量较小的情况下，串行的效率会比并发要高些，这是因为并发需要进行不断地上下文切换操作，这个操作会消耗一定的时间，但是当数据量增大的时候，并发的效率反而会更加高。

减少上下文切换操作的方法：
1.无锁并发编程。多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同
2.CAS算法。Java的Atomic包使用CAS算法来更新数据，而不需要加锁。
3.使用最少线程。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态。
4.协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。

死锁
锁这种工具是非常有效的，但是在并发编程里面，锁的过多使用容易造成资源的相互争夺，当两个或者多个线程都持有对方相应的资源而不肯释放的情况下，会出现死锁这种现象，导致系统卡死,或功能失效。
下边来举一个死锁的案例代码：

package 并发编程01.死锁的案例;

import java.awt.*;

/*
*
* @author idea
* @date 2018/7/13
* @des 模拟在多线程编程里面出现的死锁情况
* 这一段代码的主要功能就在于让t1,t2两个线程互相抢占对方的资源，导致双方都没办法获取到相应的锁
*/
public class DeadLock {
    public String locka="a";
    public String lockb="b";

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

    }

    public void deadLock(){
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (locka){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lockb){
                        System.out.println("this is a");
                    }
                }
            }
        });
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockb){
                    synchronized (locka){
                        System.out.println("this is b");
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

如何预防死锁这种情况呢？

1.避免一个线程同时获取多个锁。
2.避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
3.尝试使用定时锁，使用lock.tryLock（timeout）来替代使用内部锁机制。
4.对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

资源的抢夺

但是光只是从这些方面来考虑问题还远不远不够，因为并发实际是一个非常复杂的场景问题，并发的高效性还和资源的数量有关，因此我们不得不得提及到一个概念，叫做资源限制

资源限制是指在进行并发编程时，程序的执行速度受限于计算机硬件资源或软件资源。例如，服务器的带宽只有2Mb/s，某个资源的下载速度是1Mb/s每秒，系统启动10个线程下载资源，下载速度不会变成10Mb/s，所以在进行并发编程时，要考虑这些资源的限制。硬件资源限制有带宽的上传/下载速度、硬盘读写速度和CPU的处处理速度。软件资源限制有数据库的连接数和socket连接数等。

如何解决资源限制问题？

对于硬件资源限制，可以考虑使用集群并行执行程序。既然单机的资源有限制，那么就让程序在多机上运行。比如使用ODPS、Hadoop或者自己搭建服务器集群，不同的机器处理不同的数据。可以通过“数据ID%机器数”，计算得到一个机器编号，然后由对应编号的机器处理这笔数据。

对于软件资源限制，可以考虑使用资源池将资源复用。比如使用连接池将数据库和Socket连接复用，或者在调用对方webservice接口获取数据时，只建立一个连接。