首页 > 代码库 > 内存、线程安全与并发

内存、线程安全与并发

@内存机制引用自

一、java内存机制
java程序在内存中的分配有4种,分别是:

  1. 全局数据区:保存static修饰的属性;
  2. 全局代码区:保存static修饰的静态方法;
  3. 栈内存空间:保存所有的对象名称,这些对象名称指向对象所在的堆内存空间;
  4. 堆内存空间:保存对象;

二、java变量的作用域:
java变量分为4种:

    1. 类变量:也称为全局变量或者静态变量,需要用修饰符static修饰,在类定义后就分配内存空间,对应内存中的全局数据区,无需实例化就可以使用;
    2. 对象变量:也称为成员变量,实例化之后才分配内存空间,才可以被访问;
    3. 方法变量:也称为局部变量,是在方法内定义的变量;
    4. 块变量:就是在if、fou等语句内部定义的变量,其生存周期在块的内部,出了块就不能被访问了。

为什么使用单例模式?

因为一个类返回一个对象的引用和一个实例化方法,大大节约了内存且有利于gc回收。(对象为null时也会回收,由于Java的垃圾回收机制,Java不需要像C或C++那样通过程序代码来显示地释放空间,而会由JVM自行回收,这部分空间何时回收是不可预知的。@Author

@单例模式

通常单例类被设计成这样:

public class Singleton {

    /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */
    private static Singleton instance = null;

    /* 私有构造方法,防止被实例化 */
    private Singleton() {
    }

    /* 静态工程方法,创建实例 */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
        return instance;
    }
}
这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,原因如下:

加入线程1和2同时访问时,若对象为null,会重复初始化

改进办法是加上sychronized实现线程同步,

在实例化变量时:

public static Singleton getInstance() {
        if (instance == null) {
            synchronized (instance) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

这样在第一次创建对象时加锁,以后就不需要了。

但这样还是可能会发生问题

在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的
    Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了,我们以A、B两个线程为例:

a>A、B线程同时进入了第一个if判断

b>A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();

c>由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员(注意此时JVM没有开始初始化这个实例),然后A离开了synchronized块。

d>B进入synchronized块,由于instance此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

e>此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。
深入到jvm理解时这样的:

new 对象时jvm

a.给实例分配内存

b.初始化构造器

c.将引用指向分配的内存空间(这时引用就不是null了)

一般执行顺序是a->b->c,但由于jvm优化乱序,可能会a->c->b,当另外一个线程访问时,发现引用不为null,于是返回做相应的内存操作,这时就会发生异常

上面是懒汉模式,饿汉模式避免了这个问题

public class SingletonTest {  
    // 定义一个私有的构造方法
    private SingletonTest() {  
    }  
    // 将自身的实例对象设置为一个属性,并加上Static和final修饰符
    private static final SingletonTest instance = new SingletonTest();  
    // 静态方法返回该类的实例
    public static SingletonTest getInstancei() {  
        return instance;  
    }  
}

饿汉模式写起来比较简单,而且不存在多线程同步问题,避免了synchronized所造成的性能问题,但当类SingletonTest被加载的时候,会初始化static的instance,静态变量被创建并分配内存空间,从这以后,这个static的instance对象便一直占着这段内存(即便你还没有用到这个实例),当类被卸载时,静态变量被摧毁,并释放所占有的内存,因此在某些特定条件下会耗费内存。@Author

实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。
这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,
这样我们就不用担心上面的问题
。同时该方法也只会在第一次调用的时候使用互斥机制,
这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式@Author:
public class Singleton {

    /* 私有构造方法,防止被实例化 */
    private Singleton() {
    }

    /* 此处使用一个内部类来维护单例 */
    private static class SingletonFactory {
        private static Singleton instance = new Singleton();
    }

    /* 获取实例 */
    public static Singleton getInstance() {
        return SingletonFactory.instance;
    }

    /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
        return getInstance();
    }
}

springmvc默认时singoleton(单例模式)的、多线程的,因此,若类zhong 含有有状态对象时,

@有状态无状态

 

技术分享
    /** 
     * 有状态bean,有state,user等属性,并且user有存偖功能,是可变的。 
     *  
     * @author Peter Wei 
     *  
     */  
    public class StatefulBean {  
      
        public int state;  
        // 由于多线程环境下,user是引用对象,是非线程安全的  
        public User user;  
      
        public int getState() {  
            return state;  
        }  
      
        public void setState(int state) {  
            this.state = state;  
        }  
      
        public User getUser() {  
            return user;  
        }  
      
        public void setUser(User user) {  
            this.user = user;  
        }  
    }  
      
    /** 
     * 无状态bean,不能存偖数据。因为没有任何属性,所以是不可变的。只有一系统的方法操作。 
     *  
     * @author Peter Wei 
     *  
     */  
    public class StatelessBeanService {  
      
        // 虽然有billDao属性,但billDao是没有状态信息的,是Stateless Bean.  
        BillDao billDao;  
      
        public BillDao getBillDao() {  
            return billDao;  
        }  
      
        public void setBillDao(BillDao billDao) {  
            this.billDao = billDao;  
        }  
      
        public List<User> findUser(String Id) {  
    return null;  
        }  
    }  
View Code

 

就线程不安全了(单线程顺序、选择体、循环体执行,因此安全)。如果将singoleton(默认)改为prototype,,又回到了最初的问题,即所有的请求都创建新的实例对象,

性能大打折扣。所以尽量controller中不使用有状态对象。

综上,多线程并发访问springmvc时,为了保证不出现脏数据,在singoleton的前提下,应当保证controller中不出现有状态对象,在关键操作部分如订单数据增删改查应线程同步

(此时,若方法sychronized,sql语句就无需for update加锁了。(for update加锁后其它用户只能读不能谢,增删改默认的是开启事务,完毕后自动commit))

 

内存、线程安全与并发