关闭

多线程_并发访问_锁机制_servelt

标签: 多线程servletstrutsjavaactionspring
1733人阅读 评论(0) 收藏 举报
分类:
struts1 的前端控制器是单例的,线程不安全的;每次请求都会用同一actionServlet;
     struts2 的action不是单例的,线程安全的;每次请求都会新new一个action来接收;
     Spring的IOC容器管理的bean默认是单例的;

     如果项目中整合 struts2 和 spring ,由spring来管理struts2的action,会有问题:
          1、struts2的action有状态,有自己的成员属性,所以在多线程下,肯定有问题;    
     如何解决:
          方案1:不用单例,spring中bean的作用域设置为prototype,每个请求对应一个实例;
                         不用request,因为request作用域只适用于 WebApplicationContext环境;
                         【spring bean的作用域有5个:singleton、prototype、request、session、globalSession】      
     【
          struts1    是单例的,但每次请求,用actionform包装数据是新的;
          struts2 不是单例的,用action来取代了s1的actionForm和action的功能,提交的数据和渲染到页面的数据都在action里,这是没法共享的。
      】
----------------------------------------------------------------------------------------------------------------
     参考:
    
     servlet /jsp 默认是以多线程模式执行的。
     servelt建立在以java多线程机制之上,生命周期由web容器负责。
          当客户端第一次请求某个servlet时,servlet容器将会根据web.xml配置文件实例化这个servlet类,当有新的客户端请求servlet时,一般不会再实例化该servlet类,也就是多个线程在使用这个实例。
          Servlet容器自动使用线程池等技术来支持系统的运行。

     servlet的线程安全问题主要是由实例变量使用不当引起的。 
----------------------------------------------------------------------------------------------------------------
在设计并发访问的时候,要考虑什么用锁,同步

多线程安全:
     要认识java的线程安全,必须了解两个主要的点:java的内存模型、java的线程同步机制;
java内存模型:
     不同的平台,内存模型是不一样的,但是jvm的内存模型规范是统一的。java的多线程并发问题最终会反映在java的内存模型上。
     所谓线程安全是要控制多个线程对某个资源的有序访问或修改。
    
     要解决两个主要的问题:可见性和有序性。
     [
          计算机有高速缓存的存在,处理器并不是每次处理数据都是取内存的。
          JVM定义了自己的内存模型,屏蔽了底层内存管理细节,对于java开发人员,要解决的是在jvm内存模型基础上,如何解决多线程的可见性和有序性。
     ]         
可见性:
       多个线程之间不能互相传递数据通信,它们之间的沟通只能通过共享变量进行。Java内存模型规定了jvm有主内存,主内存是多个线程共享的。当new一个对象的时候,也是被分配在主内存中,每个线程都有自己的工作内存,工作内存存储了主存的某些对象的副本,当然线程的工作内存大小是有限制的。
执行顺序如下:
1、从主存复制变量到当前工作内存(read and load)
2、执行代码,改变共享变量值(use and assign)
3、用工作内存数据刷新主存相关内容(store and write)
      当一个共享变量在多个线程的工作内容中都有副本时,如果一个线程修改了这个共享变量,那么其他线程应该能够看到这个被修改后的值,这就是多线程的可见性。
有序性:
     线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有改变量,则会从主内存中copy一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从内存中获取变量副本(read-load-use),也有可能直接引用原来的副本,也就是说read,load,use顺序可以由JVM实现系统决定;  

      线程不能直接为主存中字段赋值,它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区,至于何时同步过去,根据JVM系统决定。

Java代码  

    package thread;  
      
    /** 
    * 
    * @author Administrator 
    * 不用synchronized 修饰add reduce方法, 每次执行的结果是不确定的。 
    * 因为线程的执行顺序是不可预见的,这是java同步产生的根源。 
    *  synchronized关键字保证了多个线程对于同步块是互斥的, 
    *  这种同步手段,解决了java多线程的执行有序性和内存可见性。 
    * 
    * 
    */  
    public class MyAccount {  
         private int balance;  
           
         public MyAccount(int b){  
              this.balance = b;  
         }  
           
         public void add(int num){  
              balance += num;  
         }  
           
         public void reduce(int num){  
              balance -= num;  
                
         }  
           
         public static void main(String[] args){  
              MyAccount account = new MyAccount(999);  
              Thread addT = new Thread(new AddThread(account,10),"add");  
              Thread redT = new Thread(new AddThread(account,10),"reduce");  
                
              try {  
                   addT.start();  
                   redT.start();  
                
                   addT.join();  
                   redT.join();  
                     
              } catch (InterruptedException e) {  
                   e.printStackTrace();  
              }  
                
              System.out.println(account.balance);  
         }  
           
         static class ReduceThread implements Runnable{  
              MyAccount account;  
              int amount;  
                
              public ReduceThread(MyAccount ac,int am){  
                   this.account = ac;  
                   this.amount = am;  
              }  
                
              public void run(){  
                   for(int i=0;i<2000;i++){  
                        account.reduce(amount);  
                   }  
              }  
         }  
           
           
         static class AddThread implements Runnable{  
              MyAccount account;  
              int amount;  
                
              public AddThread(MyAccount ac,int am){  
                   this.account = ac;  
                   this.amount = am;  
              }  
                
              public void run(){  
                   for(int i=0;i<2000;i++){  
                        account.add(amount);  
                   }  
              }  
         }  
    }  

synchronized(锁){
     临界区代码;    
}
对于public synchronized void add(int num)这种情况,意味着,锁就是这个方法所在的对象。同理,如果方法是public static synchronized void add(int num),那么锁就是这个方法所在的class。

     理论上,每个对象都可以作为锁,但一个对象作为锁时,应该被多个线程共享,这样才有意义,在并发环境下,一个没有共享的对象作为锁时没有意义的。(也就是一个临时变量作为锁是没有意义的。)
public class ThreadTest{ 
  public void test(){ 
     Object lock=new Object(); 
     synchronized (lock){ 
        //do something 
     } 
} 
} 
lock变量作为一个锁存在根本没有意义,因为它根本不是共享对象,每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock,根本不存在锁竞争。

     每个锁对象都有两个队列,一个就绪队列,一个是阻塞队列,
     就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个线程被唤醒(notify)后,才会进入到就绪队列,等待cpu调度。
    
     当一开始线程a执行account.add方法时,jvm会检查锁对象account的就绪队列是否已经有线程在等待,如果有则表明account的锁已经被占用了,由于是第一次运行,account的就绪队列为空,所以线程a获得了锁,执行account.add方法。如果恰好这个时候,线程b要执行account.reduce方法,因为线程a已经得到锁还没有释放,所以线程b要进入account的就绪队列,等得到锁后才可以执行。
    
   一个线程执行临界区代码过程如下:
      1、获得同步锁;
      2、清空工作内存;
      3、从主存copy变量副本到工作内存;
      4、对这些变量计算;
      5、将变量从工作内存写回到主存;
      6、释放锁。

     可见,synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性.

原文地址:http://lijackly.iteye.com/blog/809068

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:659280次
    • 积分:6925
    • 等级:
    • 排名:第3287名
    • 原创:31篇
    • 转载:247篇
    • 译文:7篇
    • 评论:99条
    最新评论