我们有时貌似熟悉异步、多线程、任务和并行，但有时又不一定特别清楚它们之前的本质区别，甚至在很多复杂的场景下乱用一气。下面我就结合场景来说明在什么情况下该采用什么。同时，还讲解下如何优雅地控制线程，处理任务和并行中的异常。
 
 一、在什么场景可以使用多线程
想要同时处理多件事：单线程处理不了的，必须使用多线程。（类似于分身术）
多个线程分解大任务：用单线程可以做，但是使用多线程可以更快。（类似于左右开弓）
例1：同时处理2件事
          场景描述： 执行实际工作20秒钟，20秒时间到结束执行。
public class CalculatePrimes extends Thread{

 //使用两个线程，一个用于计时(线程会休眠20秒然后设置一个主线程要检查的标志finished)，一个用于执行实际工作。在执行实际工作的线程启动前启动计时线程。
//达到20秒钟主线程将停止。

 public static final int SECONDS = 20000;

 

 public volatile boolean finished = false;

 

 public void run(){

  System.out.println("开始执行实际工作啦");

  for (long i = 0l; i < Long.MAX_VALUE; i++) {

   if(finished){

    break;

   }

   if(i%100000000==0){

    System.out.println("i:"+i);

   }

  }

  System.out.println("结束执行实际工作啦");

 }

 

 public static void main(String[] args){

  //通过实例化CalculatePrimes类型的对象来创建线程。

  CalculatePrimes calculator = new CalculatePrimes();

  calculator.start();

  try{

   System.out.println("执行Thread.sleep前，时间为："+System.currentTimeMillis());

   Thread.sleep(SECONDS);

   System.out.println("执行Thread.sleep后，时间为："+System.currentTimeMillis());

  }catch(InterruptedException e){

   

  }

  calculator.finished = true;

  System.out.println("执行完main()");

 }

}
执行结果如下：
执行Thread.sleep前，时间为：1325663362824

开始执行实际工作啦

i:0

i:100000000

i:200000000

i:300000000

i:400000000

i:500000000

i:600000000

i:700000000

i:800000000

i:900000000

i:1000000000

i:1100000000

i:1200000000

i:1300000000

执行Thread.sleep后，时间为：1325663382824

结束执行实际工作啦

执行完main()
 或者用TimerTask来实现：
public class CalculatePrimes extends Thread{

 //使用两个线程，一个用于计时(线程会休眠10秒然后设置一个主线程要检查的标志finished)，一个用于执行实际工作。在执行实际工作的线程启动之前，启动计时线程。达到10秒钟主线程将停止。

 public static final int SECONDS = 20000;

 

 public volatile boolean finished = false;

 

 public void run(){

  System.out.println("开始执行实际工作啦");

  for (long i = 0l; i < Long.MAX_VALUE; i++) {

   if(finished){

    break;

   }

   if(i%100000000==0){

    System.out.println("i:"+i);

   }

  }

  System.out.println("结束执行实际工作啦");

 }

  

 public static void main(String[] args){

  final CalculatePrimes calculator = new CalculatePrimes();

  calculator.start();

  

  Timer timer = new Timer();

  timer.schedule(

    new TimerTask(){

     public void run(){

      calculator.finished = true;

     }

    }, SECONDS);

 }

}
例2：计算密集型的一件事
应用场景：从一个非常大的数组中查找值最大的元素。
 
public class TenThreads {

 

 private static class WorkerThread extends Thread{

  int max = Integer.MIN_VALUE;

  

  int[] ourArray;

  

  public int getMax(){

   return max;

  }

  

  public WorkerThread(int[] ourArray){

   this.ourArray = ourArray;

   for (int i = 0; i < ourArray.length; i++) {

    System.out.print(ourArray[i]+"    ");

   }

   System.out.println();

  }

  

  public void run(){

   for (int i = 0; i < ourArray.length; i++) {

    max = Math.max(max,ourArray[i]);

   }

  }

  

 }

 

 public static void main(String[] args){

  WorkerThread[] threads = new WorkerThread[9];

  int[][] bigMatrix = {{1,10,100},{2,20,200},{3,33,333},{4,40,444},{5,50,500},{6,66,666},{7,77,777},{8,88,888},{9,99,999}};

  int max = Integer.MIN_VALUE;

  for (int i = 0; i < 9; i++) {

   threads[i] = new WorkerThread(bigMatrix[i]);

   threads[i].start();

  }

  

  try{

   for (int i = 0; i < 9; i++) {

    threads[i].join();

    max = Math.max(max,threads[i].getMax());

   }

  }catch(InterruptedException e){

   

  }

  System.out.println("Maximum value is:"+max);

 }

}
执行结果：
1    10    100    

2    20    200    

3    33    333    

4    40    444    

5    50    500    

6    66    666    

7    77    777    

8    88    888    

9    99    999    

Maximum value is:999
当然这个示例程序的数据量不大，只起到示例说明的作用，只要大家明白意图就好，大任务在实际工作中还是会遇到比较多的。
 
二、区分异步和多线程应用场景
举个场景--要获取某个网页的内容并显示出来。来看下应该选择异步还是多线程更适合。
可以预见，如果该网页的内容很多，或者当前的网络状况不太好，获取网页的过程会持续较长时间。
于是，我们可能会想到用 新起工作线程的方法来完成这项工作，这样在等待网页内容返回的过程中界面就不会被阻滞了。是的，上面的程序解决了界面阻滞的问题，但是，它高效吗？答案是：不。因为这样是为了获取网页，新起了一个工作线程，然后在读取网页的整个过程中，该工作线程始终被阻滞，直到获取网页完毕为止。在整个过程中，工作线程被占用着，这意味着系统的资源始终被消耗着、等待着。
如果使用异步模式去实现，它使用线程池进行管理。新起异步操作后，会将工作丢给线程池中的某个工作线程来完成。当开始I/O操作的时候，异步会将工作线程还给线程池，这意味着获取网页的工作不会再占用任何CPU资源了。直到异步完成，即获取网页完毕，异步才会通过回调的方式通知线程池。可见，异步模式借助于线程池，极大地节约了CPU的资源。
注：直接内存访问，是一种不经过CPU而直接进行内存数据存储的数据交换模式。通过直接内存访问的数据交换几乎可以不损耗CPU的资源。在硬件中，硬盘、网卡、声卡、显卡等都有D直接内存访问功能。异步编程模型就是让我们充分利用硬件的直接内存访问功能来释放CPU的压力。

明白了异步和多线程的区别后，我们来总结下两者的应用场景：
计算密集型工作，采用多线程。
IO密集型工作，采用异步机制。
 
三、线程在现有其他技术中的应用
      在使用下面这些技术是，我们必须始终假设可以在多个线程中并发地执行的情境，这就要求我们必须适当同步共享数据。
Servlet和JSP技术
        Servlet容器创建多个线程，在这些线程中执行servlet请求。在你写servlet程序时，你不需要知道你的servlet请求是在什么线程中执行的。但是你要知道，如果同时有多个对相同URL的请求入栈，那么同一个servlet可能会同时在多个线程中是活动的。这要求我们再编写servlet或jsp时，必须始终假设可以在多个线程中并发地执行同一个servlet或jsp的情境，这就要求我们必须适当同步servlet或jsp文件访问的任何共享数据，包括servlet对象本身的字段。
      2.    现实RMI对象
        RMI让你可以调用在其他JVM中运行的对象并对其进行操作。当调用远程方法时，RMI编译器创建的RMI存根会打包方法参数，并通过网络警它们发送到远程系统，然后远程系统会将它们解包并调用远程方法。
        假设你创建了一个RMI对象，并将它注册到RMI注册表或者JNDI名称空间（Java Naming and Directory Interface即Java命名和目录接口）。当远程客户机调用其中的一个方法是，该方法会在什么线程中执行呢？假设RMI对象的常用方法是继承UnicastRemoteObject,在构造UnicastRemoteObject时，会初始化用于分派远程方法调用的基础结构，这包括用于接收远程调用请求的套接字侦听器和一个或多个执行远程请求的线程。所以，当接收到执行RMI方法的请求时，这些方法将在RMI管理的线程中执行。
       3.Collection集合类
       Collection集合类在自身实现时并没有使用同步，这就意味着程序员在使用集合类时，在多线程的情境下如果没有进行同步，是有可能出问题的，即不能在不进行同步的情况下在多线程场景下使用集合类。通过每次访问共享集合中的方法时使用同步，可以在多线程应用程序中使用Collection类。对于任何给定的集合，每次必须用同一个锁进行同步。通常可以选择集合对象本身作为锁。另一种方法是使用Collections类提供的一组List、Map、Set的封装器。如可以用Collections.synchronizedMap封装Map，它将确保所有对该映射的访问都被正确同步了。
          
               


 

获取线上版本号是一件很耗时的操作，所以开辟一个子线程，代码如下



//检测新版本
    //说明：开辟子线程运行耗时代码块，然后在主线程中刷新和显示
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
            //检测新版本
            self.hasNewVersion = [self checkVersion];
            [self.tableView reloadData];
          
        });

此处加了一个 hasVersion 标识，它控制着版本升级提示的红点显示。中间遇到的一个问题就是红点该显示的没有显示出来，或是很久才显示出来，对tableView上的cell做点击操作，第一次点击不会响应，点击或者滑动tableView红点立刻就显示出来了，显然，红点显示没有放在主线程中进行，当滑动tableView时主线程刷新红点才出来，于是把上面代码中tableView的刷新加在了主线程

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
            //检测新版本
            self.hasNewVersion = [self checkVersion];
    
            dispatch_async(dispatch_get_main_queue(), ^{
                [self.tableView reloadData];
            });
        
        });


这样红点提示就顺利显示出来了。原来之前的刷新房子啊了子线程中。注意到，放在子线程中刷新UI，为什么会出现红点有时会出现有时不会呢？

带着这个问题查阅了网上的资料，其中http://blog.sina.com.cn/s/blog_45e2b66c0102v254.html这篇文章给了我很大启发，子线程中对所有其他UI更新都要等到该子线程生命周期结束才进行，如果子线程一直在运行，则子线程中的UI更新的函数栈主线程无法获知，即无法更新。



//MARK:查看新版本
- (BOOL)checkVersion {
    BOOL hasNewVersion = NO;
    NSString *newVersion;
    NSURL *url = [NSURL URLWithString:@"http://itunes.apple.com/cn/lookup?id=xxxxxxx"];
    NSString *jsonResponseString = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:nil];
    if (jsonResponseString != nil) {
        NSData *data = [jsonResponseString dataUsingEncoding:NSUTF8StringEncoding];
        //解析json数据
        id json = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableContainers error:nil];
        NSArray *array = json[@"results"];
        
        for (NSDictionary *dic in array) {
            newVersion = [dic valueForKey:@"version"];
        }
        Log(@"通过appStore获取的版本号是：%@",newVersion);
        
        //获取本地软件的版本号
        NSString *localVersion = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleShortVersionString"];  //CFBundleVersion--获取当前build版本   CFBundleShortVersionString--获取当前app版本
        
        [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"findNewVersion"];
        
        //对比发现的新版本和本地版本
        NSComparisonResult comparisonResult = [localVersion compare:newVersion options:NSNumericSearch];
        
        switch (comparisonResult) {
                
            case NSOrderedSame:
                Log(@"本地版本与线上版本相同不需要更新");
                hasNewVersion = NO;
                break;
                
            case NSOrderedAscending:
                Log(@"本地版本 < 线上版本，需要更新");
                [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"findNewVersion"];
                hasNewVersion = YES;
                break;
                
            case NSOrderedDescending:
                Log(@"本地版本 > 线上版本，不需要更新");
                hasNewVersion = NO;
                break;
                
            default:
                break;
        }
    }
    return hasNewVersion;
};

 通过表的归纳和总结说明：
                                         




1）需要频繁创建销毁的优先用线程（进程的创建和销毁开销过大）

原因请看上面的对比。

这种原则最常见的应用就是Web服务器了，来一个连接建立一个线程，断了就销毁线程，要是用进程，创建和销毁的代价是很难承受的

2）需要进行大量计算的优先使用线程（CPU频繁切换）

所谓大量计算，当然就是要耗费很多CPU，切换频繁了，这种情况下线程是最合适的。

这种原则最常见的是图像处理、算法处理。

3）强相关的处理用线程，弱相关的处理用进程

什么叫强相关、弱相关？理论上很难定义，给个简单的例子就明白了。

一般的Server需要完成如下任务：消息收发、消息处理。“消息收发”和“消息处理”就是弱相关的任务，而“消息处理”里面可能又分为“消息解码”、“业务处理”，这两个任务相对来说相关性就要强多了。因此“消息收发”和“消息处理”可以分进程设计，“消息解码”、“业务处理”可以分线程设计。

当然这种划分方式不是一成不变的，也可以根据实际情况进行调整。

4）可能要扩展到多机分布的用进程，多核分布的用线程

原因请看上面对比。

2020-10-17:volatile有什么用？能否用一句话说明下volatile的应用场景？ 
前言
volatile有什么用？能否用一句话说明下volatile的应用场景？

前言

每日一题专栏

volatile有什么用？能否用一句话说明下volatile的应用场景？
volatile保证内存可见性和禁止指令重排。
volatile用于多线程环境下的一写多读，或者无关联的多写。