可能和spring产生这个处理器的方式有关。
也就是单例还是多例。
也就是类似struts1和struts2的区别。

也就是说，
如果是struts1的模式
每次发起一个请求，都是同一个action来处理，那么写个同步块还是有效果的。
如果是struts2的模式
每次发起一个请求，都是单独的action来处理，那么写个同步也就没有效果了。
因为本来就不是一个同一个程序块在处理。

应该是这个原因。

再看看大家的解释吧。

good luck

单例的问题估计。 配置上再试试。

直接把锁加到方法上试试,如果有问题,可能是该类产生了多个实例
如果没有问题,那就是String的实例问题吧

引用 楼主 longtian2222 的回复:

在springmvc的controller层中
       
       @RequestMapping(“/test”)
public String test(HttpServletRequest request)
{
           String str=request.getParameter(“param”);

              synchronized (str)
              {
                   //
               }
        }

请问各位大神，request传递的param参数一样，为什么synchronized 同步块不能实现同步？

spring默认的就是单列

private Object lock = new Object();
public String test(HttpServletRequest request)
{
           String str=request.getParameter(“param”);

              synchronized (lock)
              {
                   //
               }
        }
这样是有效果的，说明是单列

public class Test
{

/**
 * @param args
 */
public static void main(String[] args)
{
Thread t1 = new SynchronizedTest(“1″+”1”);
Thread t2 = new SynchronizedTest(“2”);
Thread t3 = new SynchronizedTest(“3”);
Thread t4 = new SynchronizedTest(“1″+”1”);

t1.start();
t2.start();
t3.start();
t4.start();
}
}

public class SynchronizedTest extends Thread
{
public String num;

public SynchronizedTest(String num)
{
this.num = num;
}

@Override
public void run()
{
new SynTestShare().test(num);
}
}

public class SynTestShare
{
public void test(String num)
{
System.out.println(“———————lock”);
synchronized (num)
{
System.out.println(“———————run”);
try
{
Thread.sleep(5000);
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}

System.out.println(Thread.currentThread().getName()+”—-时间：”+getDate()+”————-“+num);
}
}

 public  String getDate()
 {
 Calendar cr = Calendar.getInstance();
 SimpleDateFormat sdFormat = new SimpleDateFormat(“yyyyMMdd HH:mm:ss S”);
 return Thread.currentThread().getName()+ sdFormat.format(cr.getTime());
 }
}

结果：
———————lock
———————lock
———————run
———————lock
———————run
———————lock
———————run
Thread-0—-时间：Thread-020140404 17:39:02 915————-11
Thread-2—-时间：Thread-220140404 17:39:02 915————-3
———————run
Thread-1—-时间：Thread-120140404 17:39:02 915————-2
Thread-3—-时间：Thread-320140404 17:39:07 926————-11

我写的一个测试列子，红色的new SynTestShare().test(num)每次都是新对象，从测试结果看来是可以同步的，太奇怪了。

每次的str不一定是同一个对象，就像==和equals的问题一样。
synchronized (str.intern()) ，可以这样试试看。
不过最好换个思路，比如做个 Map<String, Lock> 来处理。

引用 7 楼 fanslate 的回复:

每次的str不一定是同一个对象，就像==和equals的问题一样。
synchronized (str.intern()) ，可以这样试试看。
不过最好换个思路，比如做个 Map<String, Lock> 来处理。

感谢，synchronized (str.intern())这个可以实现

private static Object lock=new Object();
synchronized(lock){
        //your code……
}