在常见的多线程编程里面，我们总是希望创建多个线程来让程序的运行速度更加快速。但是，并不是启动更加多的线程就可以让程序运行地更加快速了。例如说当出现了上下文切换的情况和死锁的情况。因此下边小编会编写一些典型的案例来说明并发和串行的效率区别。
上下文切换：
使是单核处理器也支持多线程执行代码，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接口获取数据时，只建立一个连接。
