并发线程的挑战：（一）

前言：

多线程运行面临非常多的挑战，比如上下文切换，死锁等问题，以及受限于

硬件和软件的资源。

一、上下文切换

        即使是单核处理器也是支持多线程编程的，CPU通过给每一个线程分配CPU时间片来实现

这个机制。时间片是CPU分配给各个线程的时间，因为时间非常短，所以CPU通过不停地切换

线程执行，让我们感觉是多个线程同时执行，一个时间片一般是几十毫秒。

     CPU通过时间片分配算法来循环执行任务，当前的任务执行一个时间片后会切换到下一个

任务，但是切换前会保存上一个任务的状态，以便下一次切换回来，可以再加载这个任务

状态。所以任务从保存到再加载的过程就叫做上下文切换。

（一）、多线程一定快吗

 

package com.it.po.thread15;

public class ConcurrencyTest {
    private static final long count = 10000L;

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

    public static void concurrent() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                System.out.println("线程内 "+Thread.currentThread().getName());
                for (long i = 0; i < count; i++) {
                    a += 5;
                }
            }
        });
        thread.start();
        System.out.println("线程外 "+Thread.currentThread().getName());
        int b=0;
        for (long i = 0; i < count; i++) {
           b--;
        }
        thread.join();
        long endTime = System.currentTimeMillis() - start;
        System.out.println("并发endTime "+endTime+" ms b= "+b);
    }

    public 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 endTime = System.currentTimeMillis() - start;
        System.out.println("串行endTime "+endTime+" ms b= "+b+" a= "+a);
    }

}

 

线程外 main
线程内 Thread-0
并发endTime 3 ms b= -10000
串行endTime 1 ms b= -10000 a= 50000

 

。。。 

 结果

 

 表从可以看出，并发比串行慢的原因就是线程的创建和上下文的切换。

（二）、测试上下文切换次数和时长

     使用Lmbench3、vmstat 工具 测量上下文切换带来的消耗

（三）、如何减少上下文切换

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

线程和使用协成。

1）、无锁并发编程。多线程竞争锁，会切换上下文，所以用一些办法避免

用锁，如将数据的ID按照Hash算法取模分段，让不同的线程处理不同分段的数据

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

3）使用最少线程。尽量使用少一些的线程。

4）协程。在单线程里实现多任务调度，并在单线程里维持多个任务时间。

（四）减少上下文切换实战

 

 

 

 

 

 二、死锁

       锁是个非常有用的工具，运用场景非常多，但是可能会有死锁，

一旦产生死锁，就好造成系统功能不可用

package com.it.po.thread15;
public class DeadLockDemo {
    private static  String A="A";
    private static  String B="B";
    public static void main(String[] args)   {
        deadLock();
    }
    public static void deadLock()   {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
              synchronized (A){
                  try {
                      Thread.sleep(2000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  //锁B
                  synchronized (B){
                      System.out.println("t1");
                  }
              }
            }
        });
        //
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (B){
                    synchronized (A){
                        System.out.println("t2");
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

 

 

 

 

         开发中你可能不会写这样的代码，但是有可能是如t1拿到锁之后，出现异常没有释放锁（死循环），

又或者是t1拿到一个数据库锁，释放锁的时候抛出了异常，没有释放掉。

         一旦出现死锁，业务是可以感知的，因为不能继续提供服务了，只能通过dump线程查看

到底哪个线程出了问题，以下线程信息告诉我们 DeadLockDemo  类第

查看线程死锁，请参考《多线程：对象及变量的并发访问：synchronized和static和死锁(七)》

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

1）避免一个线程同时获取多个锁

2）避免一个线程在锁内同时占用多个资源，尽量一个锁占用一个资源。

3）尝试使用定时锁，使用lock.tryLock(timeout) 来替代使用内部锁机制。

4）对于数据库锁，加锁和解锁必须在一个数据库连接，否则会出现解锁失败

的情况。

三、资源限制的挑战

（一）什么是资源限制

     资源限制指的是在进行并发编程时，程序的执行速度受限于计算机硬件资源或是软件

资源。服务器的带宽只有2Mb/s,某一个资源的下载速度是1Mb/s，系统启动10个线程下载资源

，下载速度不会变成10Mb/s，所以在进行并发编程时，要考虑这些资源的限制。硬件资源限制

有宽度的上传/下载速度、硬盘读写速度和CPU的处理速度。软件资源的限制有数据库的链接数

和socket连接数等。

（二）、资源限制引发的问题。

       在并发线程中，将代码执行速度加快的原则是将代码中串行执行的部分变成并发的，

但是如果将某一段串行的代码并发执行，因为受限于资源，仍然在串行执行，这时候程序

不会加快执行，反而会变慢，因为增加了上下文切换和资源调度的时间，比如某程序

CPU利用率达到100%，几个小时不能运行完，改成单线程一个小时执行完。

（三）、如何解决资源限制的问题

      对于硬件资源限制，可以考虑使用集群并行执行程序，既然单机的资源有限制，那么久让程序在多机上运行

比如ODPS，Hadoop或者自己搭建服务器集群，不同的机器处理不同的数据。可以通过“ 数据ID机器数” ，计算

得到一个机器编号，然后由对应编号的机器处理这比数据。

      对于软件资源限制，可以考虑使用资源池将资源复用。比如使用连接池将数据库和socket连接复用，或者在调用

对方webservice接口获取数据时，只建立一个连接。

（四）在资源限制情况下进行并发编程

       在资源限制的情况下，如何让程序运行的更快？方法就是根据不同的资源限制调整程序的并发，

比如下载文件程序依赖于两个资源------宽带和硬件读写速度。有数据库操作时，涉及数据库连接数

如果SQL语句执行非常快，而线程的数量比数据库连接数大很多，则某一些线程会被阻塞，

等待数据库连接。

总结：

       开发并发时，一旦出现问题，一般比较棘手，强烈建议多使用JDK并发包提供的并发容器

和工具类，来解决并发问题，因为这些类都已经通过了充分的测试和优化，均可解决了本章

提到的几个挑战。