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

转载 2012年03月22日 23:53:16
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

相关文章推荐

java多线程、并发系列之 (synchronized)同步与加锁机制

SynchronizedJava中每个对象都有一个内置锁,当程序运行到非静态的synchronized同步方法上时,自动获得与正在执行代码类的当前实例(this实例)有关的锁。获得一个对象的锁也称为获...

一段多线程锁机制的代码,看完你会提高不少。

最近看到一段很有意思的代码,先贴出来。/** * * sleep(); 休眠,不会丢失任何监视器的所有权 * wait(); 等待,释放对监...

5天不再惧怕多线程——第二天 锁机制

当多个线程在并发的时候,难免会碰到相互冲突的事情,比如最经典的ATM机的问题,并发不可怕,可怕的是我们没有能力控制。 线程以我的理解可以分为三种 ① 锁。 ② 互斥。 ③ 信号。   好,这...

Java多线程总结(8)concurrent.locks包下的锁机制的使用

1 Lock与ReadWriteLock1.1 Lockpublic interface Lock { void lock(); void lockInterruptibly() th...

多线程总结☞锁机制

1:多线程共享资源的时候,一个要分出先来后到的,多线程的同步机制实际上是靠锁来完成的 2:线程同步的方式:三种方式--(1)在方法上加synchronized关键字(2)在需要做同步的代码段上加sy...

多线程中的锁机制

1、为什么要加入锁机制?   首先看一下单例设计模式中懒汉式(详情请点击博客《设计模式之--单例模式》)的一段代码: public class Student { private St...

java多线程Thread线程同步与互斥、锁机制

Thread安全线程安全不是指数据本身或者数据传输中的安全,而主要是指在高并发多线程的访问过程中,多线程对数据本身的读写所造成的数据不一致、脏数据等情况的避免。在多线程运行过程中,需要保持各个线程之间...

Java多线程 - 锁机制

为什么要锁如果多个线程修改同一个数据对象,那么会对数据造成破坏,出现“意料之外”的结果,显然不是我们想要,所以我们需要线程同步,也就是需要一把“锁”。 举个例子:package com.johan....

Java多线程4:synchronized锁机制

脏读 一个常见的概念。在多线程中,难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况,如果不做正确的同步处理,那么产生的后果就是"脏读",也就是取到的数据其实是被更改过的。  ...

对多线程对订单更新竞争的锁机制的实现-初构

做支付宝支付接入时遇到一个问题,对同一个订单,可能同时存在”支付宝服务器异步通知支付结果更新状态“和“用户主动要求发起查询支付结果更新状态"两个过程。因为在查询要用户已支付订单完成后要向其它系统发起交...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)