本帖最后由 群发软件 于 2017-7-5 23:39 编辑
JSP多线程虽然很厉但也有很多问题有侍解决
JSP默认是以多线程方式执行的，这是JSP与ASP，PHP，PERL等脚本语言不一样的地方，也是它的优势之一，但如果不注意多线程中的同步问题，会使所写的JSP程序有难以发现的错误。下面以一个例子说明JSP中的多线程问题及解决方法。 一、JSP的中存在的多线程问题：
当客户端第一次请求某一个JSP文件时，服务端把该JSP编译成一个CLASS文件，并创建一个该类的实例，然后创建一个线程处理CLIENT端的请求。如果有多个客户端同时请求该JSP文件，则服务端会创建多个线程。每个客户端请求对应一个线程。以多线程方式执行可大大降低对系统的资源需求，提高系统的并发量及响应时间.对JSP中可能用的的变量说明如下:
实例变量
实例变量是在堆中分配的，并被属于该实例的所有线程共享，所以不是线程安全的。
JSP系统提供的8个类变量，JSP中用到的OUT，REQUEST，RESPONSE，SESSION，CONFIG，PAGE，PAGECONXT是线程安全的，APPLICATION在整个系统内被使用，所以不是线程安全的。
局部变量
局部变量在堆栈中分配，因为每个线程都有它自己的堆栈空间，所以是线程安全的。
静态类
静态类不用被实例化，就可直接使用，也不是线程安全的。
外部资源:
在程序中可能会有多个线程或进程同时操作同一个资源(如:多个线程或进程同时对一个文件进行写操作).此时也要注意同步问题。
二、下面的例子存在的多线程问题：
＜%@ page import="
javax.naming.*，
java.util.*，
java.sql.*，
weblogic.common.*
" %＞
＜%
String name
String product;
long quantity;
name=request.getParameter("name");
product=request.getParameter("product");
quantity=request.getParameter("quantity"); /*(1)*/
savebuy();
%＞
＜%!
public void savebuy()
{
/*进行数据库操作，把数据保存到表中*/
try {
Properties props = new Properties();
props.put("user"，"scott");
props.put("password"，"tiger");
props.put("server"，"DEMO");
Driver myDriver = (Driver) iver").newInstance();
conn = myDriver.connect("jdbc:weblogic
racle"， props);
stmt = conn.createStatement(); String inssql = "insert into buy(empid， name， dept) values (?， ?， ?，?)";
stmt = conn.prepareStatement(inssql);
stmt.setString(1， name);
stmt.setString(2， procuct);
stmt.setInt(3， quantity);
stmt.execute();
}
catch (Exception e)
{
System.out.println("SQLException was thrown: " + e.getMessage());
}
finally //close connections and {
try {
if(stmt != null)
stmt.close();
if(conn != null)
conn.close();
} catch (SQLException sqle) {
System.out.println("SQLException was thrown: " + sqle.getMessage());
}
}
}
%＞
上面的程序模拟网上购物中的一部分，把用户在浏览器中输入的用户名，购买的物品名称，数量保存到表BUY中。在savebuy()函数中用到了实例变量，所以它不是线程安全的。因为:程序中的每一条语句都不是原子操作，如name=request.getParameter("name");在执行是会对应多个机器指令，在任何时候都可能因系统调度而转入睡眠状态，让其他的线程继续执行。如果线程A在执行到(1)的时候转入睡眠状态，线程B开始执行并改变QUANTITY的值，那么当又到A执行时，它会从调用savebuy()函数开始执行，这样它保存到表中的QUANTITY是被线程B改过的值，那么线程A对应的用户所实际购买的数量与保持到表中的数据不一致，这是个很严重的问题。
三、解决方法
采用单线程方式
在该JSP文件中加上: ，使它以单线程方式执行，这时，仍然只有一个实例，所有客户端的请求以串行方 式执行。这样会降低系统的性能。
对函数savebuy()加synchronized进行线程同步，该JSP仍然以多线程方式执行，但也会降低系统的性能：
public synchronized void savebuy()
{
......
}
采用局部变量代替实例变量，函数savebuy()声明如下:
因为在savebuy()中使用的是传给他的形参，是在堆栈中分配的，所以是线程安全的。
public void savebuy(String name，String product， int quantity)
{
......
}
调用方式改为:
＜%
String name
String product;
long quantity;
name=request.getParameter("name");
product=request.getParameter("product");
quantity=request.getParameter("quantity");
savebuy(name，product，quantity)
%＞
如果savebuy的参数很多，或这些数据要在很多地方用到，也可声明一个类，并用他做参数，如:
public class buyinfo
{
String name;
String product;
long quantity;
}
public void savebuy(buyinfo info)
{
......
}
调用方式改为:
＜%
buyinfo userbuy = new buyinfo();
userbuy.name=request.getParameter("name");
userbuy.product=request.getParameter("product");
userbuy.quantity=request.getParameter("quantity");
savebuy(userbuy);
%＞
所以最好是用3，因为1，2会降低系统的性能。
多线程问题一般只有在在大并发量访问时，才有可能出现，并且很难重复出现，所以应在编程时就时刻注意。
随着计算机技术的发展，编程模型也越来越复杂多样化。但多线程编程模型是目前计算机系统架构的最终模型。随着CPU主频的不断攀升，X86架构的硬件已经成为瓶，在这种架构的CPU主频最高为4G。事实上目前3.6G主频的CPU已经接近了顶峰。
如果不能从根本上更新当前CPU的架构(在很长一段时间内还不太可能)，那么继续提高CPU性能的方法就是超线程CPU模式。那么，作业系统、应用程序要发挥CPU的最大性能，就是要改变到以多线程编程模型为主的并行处理系统和并发式应用程序。
所以，掌握多线程编程模型，不仅是目前提高应用性能的手段，更是下一代编程模型的核心思想。多线程编程的目的，就是"最大限度地利用CPU资源"，当某一线程的处理不需要占用CPU而只和I/O,OEMBIOS等资源打交道时，让需要占用CPU资源的其它线程有机会获得CPU资源。从根本上说，这就是多线程编程的最终目的。
[第一需要弄清的问题]
如同程序和进程的区别，要掌握多线程编程，第一要弄清的问题是：线程对象和线程的区别。
线程对象是可以产生线程的对象。比如在Java平台中Thread对象，Runnable对象。线程，是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始，运行run方法体中的那一段相对独立的过程。
鉴于作者的水平，无法用更确切的词汇来描述它们的定义。但这两个有本质区别的概念请初学者细细体会，随着介绍的深入和例程分析的增加，就会慢慢明白它们所代表的真实含义。
天下难事必始于易，天下大事必始于细。
让我们先从最简单的"单线程"来入手：(1)带引号说明只是相对而言的单线程，(2)基于java。
class BeginClass{
public static void main(String[] args){
for(int i=0;i<100;i++)
System.out.println("Hello,World!");
}
}
如果我们成功编译了该java文件，然后在命令行上敲入：
Java BeginClass
现在发生了什么呢？每一个java程序员，从他开始学习java的第一分钟里都会接触到这个问题，但是，你知道它到底发生发什么？
JVM进程被启动，在同一个JVM进程中，有且只有一个进程，就是它自己。然后在这个JVM环境中，所有程序的运行都是以线程来运行。JVM最先会产生一个主线程，由它来运行指定程序的入口点。在这个程序中，就是主线程从main方法开始运行。当main方法结束后，主线程运行完成。JVM进程也随之退出。
我们看到的是一个主线程在运行main方法，这样的只有一个线程执行程序逻辑的流程我们称
之为单线程。这是JVM提供给我们的单线程环境，事实上，JVM底层还至少有垃圾回收这样的后台线程以及其它非java线程，但这些线程对我们而言不可访问，我们只认为它是单线程的。
主线程是JVM自己启动的，在这里它不是从线程对象产生的。在这个线程中，它运行了main方法这个指令序列。理解它，但它没有更多可以研究的内容。
[接触多线程]
class MyThread extends Thread{
public void run(){
System.out.println("Thread say:Hello,World!");
}
}
public class MoreThreads{
public static void main(String[] args){
new MyThread();
new MyThread().start();
System.out.println("Main say:Hello,World");
}
}
执行这个程序，main方法第一行产生了一个线程对象，但并没有线程启动。
main方法第二行产生了一个线程对象，并启动了一个线程。
main方法第三行，产生并启动一个线程后，主线程自己也继续执行其它语句。
我们先不研究Thread对象的具体内容，稍微来回想一下上面的两个概念，线程对象和线程。在JAVA中，线程对象是JVM产生的一个普通的Object子类。而线程是CPU分配给这个对象的一个运行过程。我们说的这个线程在干什么，不是说一个线程对象在干什么，而是这个运行过程在干什么。如果一时想不明白，不要急，但你要记得它们不是一回事就行了。
累了吧？为不么不继续了？
基于这种风格来介绍多线程，并不是每个人都喜欢和接受的，如果你不喜欢，正好不浪费你的时间了，而如果你接受的话，那就看下一节吧。
在进入java平台的线程对象之前，我先插入两个基本概念。
[线程的并发与并行]
在单CPU系统中，系统调度在某一时刻只能让一个线程运行，虽然这种调试机制有多种形式(大多数是时间片轮巡为主)，但无论如何，要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中，可以让两个以上的线程同时运行，这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。
在上面包括以后的所有论述中，请各位朋友谅解，我无法用最准确的词语来定义储如并发和并行这类术语，但我以我的经验能通俗地告诉大家它是怎么一回事，如果您看到我说的一些"标准"文档上说的不一样，只要意思一致，那您就不要挑刺了。
[JAVA线程对象]
现在我们来开始考察JAVA中线程对象。
在JAVA中，要开始一个线程，有两种方式。一是直接调用Thread实例的start()方法，二是
将Runable实例传给一个Thread实例然后调用它的start()方法。
在前面已经说过，线程对象和线程是两个完全不同的概念。这里我们再次深入一下，生成一个线程的实例，并不代表启动了线程。而启动线程是说在某个线程对象上启动了该实例对应的线程，当该线程结束后，并不会就立即消失。
对于从很多书籍上可以看到的基础知识我就不用多说了。既然是基础知识，我也着重于从普通文档上读不到的内容。所以本节我重点要说的是两种线程对象产生线程方式的区别。
class MyThread extends Thread{
public int x = 0;
public void run(){
for(int i=0;i<100;i++){
try{
Thread.sleep(10);
}catch(Exception e){}
System.out.println(x++);
}
}
}
如果我们生成MyThread的一个实例，然后调用它的start()方法，那么就产生了这个实例对应的线程:
public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
}
}
不用说，最终会打印出0到99，现在我们稍微玩一点花样:
public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
System.out.println(101);
}
}
也不用说，在基础篇(一)中我们知道由于单CPU的原因，一般会先打印101，然后打印0到99。不过我们可以控制线程让它按我们的意思来运行:
public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
mt.join();
System.out.println(101);
}
}
好了，我们终于看到，mt实例对应的线程(假如我有时说mt线程请你不要怪我，不过我尽量不这么说)。在运行完成后，主线程才打印101。因为我们让当前线程(这里是主线程)等待mt线程的运行结束。"在线程对象a上调用join()方法，就是让当前正在执行的线程等待线程对象a对应的线程运行完成后才继续运行。" 请大家一定要深刻理解并熟记这句话，而我这里引出这个知识点的目的是为了让你继续看下面的例子:
public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
mt.join();
Thread.sleep(3000);
mt.start();
}
}
当线程对象mt运行完成后，我们让主线程休息一下，然后我们再次在这个线程对象上启动线程。结果我们看到:
Exception in thread "main" java.lang.IllegalThreadStateException
也就是这种线程对象一时运行一次完成后，它就再也不能运行第二次了。我们可以看一下它有具体实现:
public synchronized void start() {
if (started)
throw new IllegalThreadStateException();
started = true;
group.add(this);
start0();
}
一个Thread的实例一旦调用start()方法，这个实例的started标记就标记为true，事实中不管这个线程后来有没有执行到底，只要调用了一次start()就再也没有机会运行了，这意味着:
[通过Thread实例的start()，一个Thread的实例只能产生一个线程]
那么如果要在一个实例上产生多个线程(也就是我们常说的线程池)，我们应该如何做呢?这就是Runnable接口给我们带来的伟大的功能。
class R implements Runnable{
private int x = 0;
public void run(){
for(int i=0;i<100;i++){
try{
Thread.sleep(10);
}catch(Exception e){}
System.out.println(x++);
}
}
}
正如它的名字一样，Runnable的实例是可运行的，但它自己并不能直接运行，它需要被Thread对象来包装才行运行:
public class Test {
public static void main(String[] args) throws Exception{
new Thread(new R()).start();
}
}
当然这个结果和mt.start()没有什么区别。但如果我们把一个Runnable实例给Thread对象多次包装，我们就可以看到它们实际是在同一实例上启动线程:
public class Test {
public static void main(String[] args) throws Exception{
R r = new R();
for(int i=0;i<10;i++)
new Thread(r).start();
}
}
x是实例对象，但结果是x被加到了999，说明这10个线程是在同一个r对象上运行的。请大家注意，因为这个例子是在单CPU上运行的，所以没有对多个线程同时操作共同的对象进行同步。这里是为了说明的方便而简化了同步，而真正的环境中你无法预知程序会在什么环境下运行，所以一定要考虑同步。
到这里我们做一个完整的例子来说明线程产生的方式不同而生成的线程的区别:
package debug;
import java.io.*;
import java.lang.Thread;
class MyThread extends Thread{
public int x = 0;
public void run(){
System.out.println(++x);
}
}
class R implements Runnable{
private int x = 0;
public void run(){
System.out.println(++x);
}
}
public class Test {
public static void main(String[] args) throws Exception{
for(int i=0;i<10;i++){
Thread t = new MyThread();
t.start();
}
Thread.sleep(10000);//让上面的线程运行完成
R r = new R();
for(int i=0;i<10;i++){
Thread t = new Thread(r);
t.start();
}
}
}
上面10个线程对象产生的10个线程运行时打印了10次1。下面10个线程对象产生的10个线程运行时打印了1到10。我们把下面的10个线程称为同一实例(Runnable实例)的多个线程。
|( 京ICP备09078825号 )
发表于 2017-7-5 23:37:59
收藏
发表于 2017-7-13 06:10:45
