spring 多并发lock应用

1.首先模拟spring单例模式下lock防止多并发

package com.cms;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B implements Runnable {
	
	private Lock lock = new ReentrantLock();
	
	private volatile static B b = null;
	
	private B() {}
	
	public static B getInstance() {
        if( b == null ) {
            synchronized(B.class) {
                if( b == null ) {
                    b = new B();
                }
            }
        }
		return b;
	}
	
	public void con() {
		try {
			lock.lock();
			for(int i=0;i<20;i++){
				System.out.println(Thread.currentThread().getName() + "todo" + i);
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			lock.unlock();
		}
		
	}

	@Override
	public void run() {
		con();
	}
	
	public static void main(String[] args) {
		/**
		 * 结论：
		 * 1.spring默认用的是单例模式，
		 * 所以多请求进来时lock只会被加载一次
		 * 2.如果scope设置为prototype，在多例模式下service方法会创建多个实例，lock相应的会初始化多次，所以每次请求的线程不是共享一个资源，不能防止多并发,
		 * 所以要对lock加static关键词成为类变量
		 */
		for(int i=0;i<2;i++){
			new Thread( B.getInstance() ).start();//模拟单例并发
			//new Thread( new B() ).start();//模拟多例并发
		}
	}
	
}

2.再模拟scope设置为prototype，在多例模式下的情况

package com.cms;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B implements Runnable {
	
	private Lock lock = new ReentrantLock();
	
	private volatile static B b = null;
	
	private B() {}
	
	public static B getInstance() {
		if( b == null ) {
            synchronized(B.class) {
                if( b == null ) {
                    b = new B();
                }
            }
        }
		return b;
	}
	
	public void con() {
		try {
			lock.lock();
			for(int i=0;i<20;i++){
				System.out.println(Thread.currentThread().getName() + "todo" + i);
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			lock.unlock();
		}
		
	}

	@Override
	public void run() {
		con();
	}
	
	public static void main(String[] args) {
		/**
		 * 结论：
		 * 1.spring默认用的是单例模式，
		 * 所以多请求进来时lock只会被加载一次
		 * 2.如果scope设置为prototype，在多例模式下service方法会创建多个实例，lock相应的会初始化多次，所以每次请求的线程不是共享一个资源，不能防止多并发,
		 * 所以要对lock加static关键词成为类变量
		 */
		for(int i=0;i<2;i++){
			//new Thread( B.getInstance() ).start();//模拟单例并发
			new Thread( new B() ).start();//模拟多例并发
		}
	}
	
}

如控制台所示，并不能防止并发，作为多例模式相应每次会初始化lock对象变量，共享的不是同一把锁和资源。

3.因此修改如下，将lock作为类变量，不受多例模式影响，只会初始化一次。

（PS:根据有无被final关键字修饰，类变量的初始化时机不同。被final关键字修饰的类变量在编译时就已经被初始化被放置在常量池中了，而没有被final修饰的类变量则在该类首次使用时被初始化。特别需要注意的是，类变量只在该类首次使用时被初始化，这意味着类变量只会被初始化一次。）

package com.cms;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B implements Runnable {
	
	private static Lock lock = new ReentrantLock();
	
	private volatile static B b = null;
	
	private B() {}
	
	public static B getInstance() {
		if( b == null ) {
            synchronized(B.class) {
                if( b == null ) {
                    b = new B();
                }
            }
        }
		return b;
	}
	
	public void con() {
		try {
			lock.lock();
			for(int i=0;i<20;i++){
				System.out.println(Thread.currentThread().getName() + "todo" + i);
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			lock.unlock();
		}
		
	}

	@Override
	public void run() {
		con();
	}
	
	public static void main(String[] args) {
		/**
		 * 结论：
		 * 1.spring默认用的是单例模式，
		 * 所以多请求进来时lock只会被加载一次
		 * 2.如果scope设置为prototype，在多例模式下service方法会创建多个实例，lock相应的会初始化多次，所以每次请求的线程不是共享一个资源，不能防止多并发,
		 * 所以要对lock加static关键词成为类变量
		 */
		for(int i=0;i<2;i++){
			//new Thread( B.getInstance() ).start();//模拟单例并发
			new Thread( new B() ).start();//模拟多例并发
		}
	}
	
}

spring 多并发lock应用

猜你喜欢