JAVA多线程的应用场景和应用目的举例

多线程使用的主要目的在于:

1、吞吐量:你做WEB,容器帮你做了多线程,但是他只能帮你做请求层面的。简单的说,可能就是一个请求一个线程。或多个请求一个线程。如果是单线程,那同时只能处理一个用户的请求。

2、伸缩性:也就是说,你可以通过增加CPU核数来提升性能。如果是单线程,那程序执行到死也就利用了单核,肯定没办法通过增加CPU核数来提升性能。

鉴于你是做WEB的,第1点可能你几乎不涉及。那这里我就讲第二点吧。

--举个简单的例子:
假设有个请求,这个请求服务端的处理需要执行3个很缓慢的IO操作(比如数据库查询或文件查询),那么正常的顺序可能是(括号里面代表执行时间):
a、读取文件1  (10ms)
b、处理1的数据(1ms)
c、读取文件2  (10ms)
d、处理2的数据(1ms)
e、读取文件3  (10ms)
f、处理3的数据(1ms)
g、整合1、2、3的数据结果 (1ms)
单线程总共就需要34ms。
那如果你在这个请求内,把ab、cd、ef分别分给3个线程去做,就只需要12ms了。

所以多线程不是没怎么用,而是,你平常要善于发现一些可优化的点。然后评估方案是否应该使用。


假设还是上面那个相同的问题:但是每个步骤的执行时间不一样了。
a、读取文件1  (1ms)
b、处理1的数据(1ms)
c、读取文件2  (1ms)
d、处理2的数据(1ms)
e、读取文件3  (28ms)
f、处理3的数据(1ms)
g、整合1、2、3的数据结果 (1ms)
单线程总共就需要34ms。
如果还是按上面的划分方案(上面方案和木桶原理一样,耗时取决于最慢的那个线程的执行速度),在这个例子中是第三个线程,执行29ms。那么最后这个请求耗时是30ms。比起不用单线程,就节省了4ms。但是有可能线程调度切换也要花费个1、2ms。因此,这个方案显得优势就不明显了,还带来程序复杂度提升。不太值得。

那么现在优化的点,就不是第一个例子那样的任务分割多线程完成。而是优化文件3的读取速度。
可能是采用缓存和减少一些重复读取。
首先,假设有一种情况,所有用户都请求这个请求,那其实相当于所有用户都需要读取文件3。那你想想,100个人进行了这个请求,相当于你花在读取这个文件上的时间就是28×100=2800ms了。那么,如果你把文件缓存起来,那只要第一个用户的请求读取了,第二个用户不需要读取了,从内存取是很快速的,可能1ms都不到。

伪代码:

public class MyServlet extends Servlet{
    private static Map<String, String> fileName2Data = new HashMap<String, String>();
    private void processFile3(String fName){
        String data = fileName2Data.get(fName);
        if(data==null){
            data = readFromFile(fName);    //耗时28ms
            fileName2Data.put(fName, data);
        }
        //process with data
    }
}

 

看起来好像还不错,建立一个文件名和文件数据的映射。如果读取一个map中已经存在的数据,那么就不不用读取文件了。
可是问题在于,Servlet是并发,上面会导致一个很严重的问题,死循环。因为,HashMap在并发修改的时候,可能是导致循环链表的构成!!!(具体你可以自行阅读HashMap源码)如果你没接触过多线程,可能到时候发现服务器没请求也巨卡,也不知道什么情况!
好的,那就用ConcurrentHashMap,正如他的名字一样,他是一个线程安全的HashMap,这样能轻松解决问题。

public class MyServlet extends Servlet{
    private static ConcurrentHashMap<String, String> fileName2Data = new ConcurrentHashMap<String, String>();
    private void processFile3(String fName){
        String data = fileName2Data.get(fName);
        if(data==null){
            data = readFromFile(fName);    //耗时28ms
            fileName2Data.put(fName, data);
        }
        //process with data
    }
}

 

这样真的解决问题了吗,这样虽然只要有用户访问过文件a,那另一个用户想访问文件a,也会从fileName2Data中拿数据,然后也不会引起死循环。

可是,如果你觉得这样就已经完了,那你把多线程也想的太简单了,骚年!
你会发现,1000个用户首次访问同一个文件的时候,居然读取了1000次文件(这是最极端的,可能只有几百)。What the fuckin hell!!!

难道代码错了吗,难道我就这样过我的一生!

好好分析下。Servlet是多线程的,那么

public class MyServlet extends Servlet{
    private static ConcurrentHashMap<String, String> fileName2Data = new ConcurrentHashMap<String, String>();
    private void processFile3(String fName){
        String data = fileName2Data.get(fName);
        //“偶然”-- 1000个线程同时到这里,同时发现data为null
        if(data==null){
            data = readFromFile(fName);    //耗时28ms
            fileName2Data.put(fName, data);
        }
        //process with data
    }
}

 

上面注释的“偶然”,这是完全有可能的,因此,这样做还是有问题。

因此,可以自己简单的封装一个任务来处理。

public class MyServlet extends Servlet{
    private static ConcurrentHashMap<String, FutureTask> fileName2Data = new ConcurrentHashMap<String, FutureTask>();
    private static ExecutorService exec = Executors.newCacheThreadPool();
    private void processFile3(String fName){
        FutureTask data = fileName2Data.get(fName);
        //“偶然”-- 1000个线程同时到这里,同时发现data为null
        if(data==null){
            data = newFutureTask(fName);
            FutureTask old = fileName2Data.putIfAbsent(fName, data);
            if(old!=null){//原文:old==null
                data = old;
            }else{
                exec.execute(data);
            }
        }
        String d = data.get();
        //process with data
    }
     
    private FutureTask newFutureTask(final String file){
        return  new FutureTask(new Callable<String>(){
            public String call(){
                return readFromFile(file);
            }
 
            private String readFromFile(String file){return "";}
        }
    }
}

 

以上所有代码都是直接在bbs打出来的,不保证可以直接运行。

 

多线程最多的场景:web服务器本身;各种专用服务器(如游戏服务器);
多线程的常见应用场景:
1、后台任务,例如:定时向大量(100w以上)的用户发送邮件;
2、异步处理,例如:发微博、记录日志等;
3、分布式计算

 

原文地址:http://www.cnblogs.com/kenshinobiy/p/4671314.html

本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。

博客搬家咯 - 2016-09-24 14:09:07

博客搬家了,最新地址: http://blog.uyiplus.com

关于java的10个谎言 - 2016-09-24 14:09:07

关于java的10个谎言 面试中总遇到各种奇葩的问题,小编在兄弟连网站上找到了下面的这些都算是比较高级的问题了,面试中一般也很少问到,因为它们可能会把面试者拒之门外。不过你可以自己找个时间来实践一下。 1. System.exit(0)会跳过finally块的执行 System.setSecurityManager(new SecurityManager() {         @Override         public void checkExit(int status) {            

Java 之浅复制和深复制 - 2016-09-24 14:09:07

1 浅复制和深复制区别 浅复制:浅复制只是复制本对象的原始数据类型,如int、float、String,对于数组和对象引用等是不会复制的。因此浅复制是有风险的。 深复制:不但对原始数据类型进行复制,对于对象中的数组和对象引用也做复制的行为,从而达到对对象的完全复制。 2 代码示例 package com;import java.util.ArrayList;public class Test implements Cloneable {// 私有属性private ArrayListString name
在java编程中,经常需要用到同步,而用得最多的也许是synchronized关键字了,下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念,所以先来了解一些相关的锁知识。 java的内置锁:每个java对象都可以用做一个实现同步的锁,这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁,这就是意味着最多只有一个线程能够获得该锁,当线程A尝试去获得
在eclipse的preferences里,Java-Code style-Code templates,Comments-Type编辑成如下     @author ${name:git_config(user.name)} (${mail:git_config(user.email)})
一 8种基本数据类型和8种包装类的对应关系 基本数据类型 包装类 byte Byte short Short int Interger long Long char Character float Float double Double boolean Boolean   二 自动装箱和自动拆箱 1 概念介绍  自动装箱:把一个基本数据变量直接赋给对应的包装类变量或者赋值给Object变量。  自动拆箱:允许直接把包装类对象直接赋给对应的基本类型变量。 2 代码示例 public class AutoBo

通用查询,保存方法 - 2016-09-24 14:09:04

基于jqgrid页面通用查询、保存方法

mysql的事务处理与锁表 - 2016-09-24 14:09:04

数据库的事务处理可以保证一组处理结果的正确性。mysql中只有INNODB和BDB引擎的数据表才支持事务处理,对于不支持事务的MyISAM引擎数据库可以使用表锁定的方法来实现相同的功能。 mysql的事务处理主要有两种方法来实现。 1、用begin,rollback,commit来实现。 begin 开始一个事务 rollback 事务回滚 commit 事务确认 Php代码 $conn = mysql_connect('localhost','root','root') or die ("数据连接错误!

Rsa签名算法详解 - 2016-09-23 22:09:05

Rsa签名算法详解 签名生成规则与验证签名规则如下: ① 每次生成签名时该算法都会生成一对对应的公钥和私钥对, ② 所以在应用中一般都会采取使用同一对密钥对进行签名与验签(建议使用静态变量)保证对方验证签名时用的公钥是与你生成签名用的是同一对,否则就不能通过验证 ③ 将自己生成的秘钥对中的公钥交给对方用来验证你的签名,私钥用来生成签名 ④ 同样的对方也会选定一组密钥对将公钥给你用来验证签名,用他的私钥来生成签名 ⑤ 备注:一般对安全性要求比较高的企业,不仅仅限与用rsa签名来保证安全,还会对rsa签名再次

随机产生和为S的N个正整数 - 2016-09-23 14:09:17

如果给你一个问题:“ 随机产生和为S的N个正整数 ”, 你会如何做呢?   针对该问题,解决的方法有很多种。在这篇文章中,我将为大家给出两种比较好理解的解决方法:一个是 “尺子法” ;另外一个是 “锯木头法” 。 ( 名字随便取的,主要是方便理解用 )。   方法一:尺子法   思想: 将给定值S看成一个尺子的长度,那么,生成N个和为S的正整数的问题就变成在尺子中 寻找出N-1个不同的刻度 , 加上最小刻度0和最大刻度S , 一共有N+1个刻度 。 然后,从小到大,计算出相邻刻度的长度,这些长度就可以认为