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

----------------------------------------------------------------------------------------------------------------
2010-11-11
     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系统决定。

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.add(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.reduce(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既保证了多线程的并发有序性，又保证了多线程的内存可见性；