之前开发一个分享信息的第三方平台的需求，分享时间是有间隔的，比如说20秒内只能分享一次，

多出的动态里面不显示，这样的话如果用户在20秒内连续多次分享，那么将导致只显示一次动态，

这时候就必须为每一个用户的分享操作做独立的同步，即使有多个分享操作，也是同步执行，执行间隔20秒

思路，为每个用户创建不同的映射对象，并使用这个对象作为锁

import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;public class UserThread {public static Map<String, Object> map = new HashMap<String, Object>();//存储静态的锁对象//每小时清空map对象static{long perHour = 1000*60*60;Timer perHourTimer = new Timer();perHourTimer.scheduleAtFixedRate(new TimerTask() {public void run() {map.clear();}}, perHour, perHour);}public static void syn(int userId){String key = userId+"";Object obj = map.get(key);if(obj == null){obj = new String(key);map.put(key, obj);}synchronized (obj) {try {Thread.sleep(3000);System.out.println(Thread.currentThread().getName());} catch (Exception e) {}}}/*** 会出现两种情况:* (1)第一、三、四个线程会在3秒后异步执行,第二个线程由于与第一个线程同步，6秒后才会执行* (2)第二个线程比第一个线程先抢到资源，3秒后执行，第一个线程6秒后执行*/public static void main(String[] args) {Thread t1 = new Thread(){public void run() {UserThread.syn(1);};};t1.setName("线程一");t1.start();Thread t2 = new Thread(){public void run() {UserThread.syn(1);};};t2.setName("线程二");t2.start();Thread t3 = new Thread(){public void run() {UserThread.syn(2);};};t3.setName("线程三");t3.start();Thread t4 = new Thread(){public void run() {UserThread.syn(3);};};t4.setName("线程四");t4.start();}}

为什么还会需要用到map来存储锁呢，直接用userId+作为锁对象岂不是得到如此效果，

为何还要如此的麻烦呢。那么接下来我们就这样来试试看吧。

public class UserThread {public static void syn(int userId){Object obj = userId+"";synchronized (obj) {try {Thread.sleep(3000);System.out.println(Thread.currentThread().getName());} catch (Exception e) {}}}/*** 四个线程在三秒后同时执行*/public static void main(String[] args) {Thread t1 = new Thread(){public void run() {UserThread.syn(1);};};t1.setName("线程一");t1.start();Thread t2 = new Thread(){public void run() {UserThread.syn(1);};};t2.setName("线程二");t2.start();Thread t3 = new Thread(){public void run() {UserThread.syn(2);};};t3.setName("线程三");t3.start();Thread t4 = new Thread(){public void run() {UserThread.syn(3);};};t4.setName("线程四");t4.start();}}

结果是四个线程在三秒后同时执行，为什么会这样呢。问题就出在Object

obj = userId+"";这里，下面我们执行一个main方法

public static void main(String[] args) {String str1 = "";String str2 = "";System.out.println(str1 == str2);//结果为true,这是意料之中，大家都知道，字符串有常量池String str3 = str1+str2;System.out.println(str1 == str3);//结果为false,str3也是空字符串，//可见str3不是从常量池取出的，而是组合成新的字符串对象并返回}

因此，线程一与线程二锁的对象是不一样的，所有无法实现同步。

总之，线程的同步是建立在锁对象的基础上的，谁抢到这个对象，谁就有执行的权限，

执行完后释放锁，由后面的线程继续抢夺。

以上都是针对同一个需要同步的代码块的讨论，那么不同的代码块那同一个对象作为锁会是什么结果呢

public class UserThread {public static void syn(){Object obj = "";synchronized (obj) {try {Thread.sleep(3000);System.out.println(Thread.currentThread().getName());} catch (Exception e) {}}}public static void syn2(){Object obj = "";synchronized (obj) {try {Thread.sleep(3000);System.out.println(Thread.currentThread().getName());} catch (Exception e) {}}}/*** 二个线程都是同步先后执行*/public static void main(String[] args) {Thread t1 = new Thread(){public void run() {UserThread.syn();};};t1.setName("线程一");t1.start();Thread t2 = new Thread(){public void run() {UserThread.syn2();};};t2.setName("线程二");t2.start();}}

所以，不管做何种同步操作，锁对象只能被一个线程抢到，不同的代码块，如果不是特殊需求，

千万不要使用相同对象作为锁，否则会对大大降低程序性能