Synchronized及其实现原理

并发编程中synchronized一直是元老级角色，我们称之为重量级锁。主要用在三个地方：

1、修饰普通方法，锁是当前实例对象。

2、修饰类方法，锁是当前类的Class对象。

3、修饰代码块，锁是synchronized括号里面的对象。

一、synchronized实现原理

当一个线程试图访问同步代码块时，必须得到锁。在退出或抛出异常时必须释放锁，JVM是基于进入和退出Monitor来实现方法同步和代码块同步。

我们来看下synchronized的字节码：

public class SynchronizedTest
{
    public void addNum1(String userName)
    {
    }

    public void addNum2(String userName)
    {
        synchronized(this)
        {
        }
    }

    public synchronized void addNum3(String userName)
    {
    }
}

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAh8AAAI5CAIAAACOys+tAAAgAElEQVR4nO3dTZfjRnYmYP46S721ejvuv8qtVFurfM4ce0aq6S+3uqX+smc7ixplMxERFxHABQiAz7NCgsEbN4JMvMUsMvP277/+4Re//NX9we29e6E8Xw5+/DIYP7lLtYFWP0H92SI99ct1lcc9Z/r7CfazrDC7n8FdWp239rOn+SGt/Wn1M9rnvdBzvlofWOg/fvPHX/zyV8/uIsHQFaG8yuxzQXnWvAB7u0a6uFIDHMs10gWAY/lf0gWAdNIFgHzSBYB8//u3f5IuACR7TJcd3nlVFl826dBdnvJ2stbHKTbd5J3fWp1Vp7o5z3oH4KYPzaZTwLG8pcs+z/5W5QUzdt7lbdjO39LV/dxhk8+VLrdiT27vt2tl5ZX9JJIuvJzP6TJ5uu//7N8hXXZ27XRJVDacsoSj7YN04eV897tKujy6P6ieDC6jrbu0Zpmdt5x6doHVYY937+mztd7ZqcuD1n3jbRzdn2rBxeudnTfYn546rSX0r7e/n0B//49fdq73Vns+wJV997sfg3RpfRe9Hd8bF7LyuHWmer6nYM9VI7jEPC5hcjy03lHBpac63eg+zC5naL2txZaTxgsZqh+fGdqH27jWHYf2Z00DcBHfHzhdHvUUr4pnnPS/YL3LxDvT309cuTweXW9rrnhXJ18+6qnfOlPW6e+kX7yE2f5bfcLL+f73lXR5+3L2O6pzWFl5YsElo/O7d+jqs2C9Q2avSuV0nRvbv4TRwbN3HBrWU7+z+Mq79JTKOoZX9On3PwbvGZv9zukc9qbnctNZsPO7t3PGzrnK9Q7p2ZzRtS/YuqHBs3esfrmmfnxmdB9a1cpFLagf7EMwBbyEt3S5hd8ws1eTyTdVXCcYXz3/2PDjydlv4Nki5d1H1zsqmLos3jqO+yzvsma9wbzV+j193tqP4+z4zvPlbgTne9bbuikoXh0Ar+IxXVL4jlrD7j1FkC7AQp/+86fEdAn+IUnAvj2dhwCS/Z/UdAGA2026ALCFX/9BugCQ7dd/+LN0ASCZdAEg328WpUvw7pr4vTfbvSfnWe/52XTe3VaUNcuk4Xth/RSnkLjenfftiQ9WOW9PJ5u2+mrP22S/+WHha5d40/dPl33qB9NtGjDpZbebZbInj2dWTrH1PuTWP2m6PGvSxydJGTA9d1wz9UaVX93O6bI16fJ0ZcMpS9h6H9Lrn+6Be/TE76PbLt9Wrak7b6LL53SZ/MOh+tBWnwGT8ZNbyzP951vi8evnHeqn86lZbu9oP9WC5flWndF574XOPuMl9K+3v5+WoE755eh6ZxfbWWfxEoJ1rZ+3LNLTTGt8tVo8XbmceIqe9fb03+qBhX7782uX8hFtnSy/bD2W5XRDReK7V8cHRVr37TmebSnuZHY/Z/c5uPvsgJ51lZPGCxmqH58Z2odbn546PfXXrH1o/zvXMtpbT52hSTvnHV1v8FjMllrZz2xNlvvtD385SLr0mB3f6uTNaIeLGxvaz2DS+C6Tsj31q3MNPV7lfsb1W2fKOv2dxIL6t/dbF9cfXW+wD0P9B40N9dMaPzrp6LxBP/1r7CxVDoj7nF1pf9vMuHa6DD01hyaarT+0n53P/qHlLL7j0LCe+p3FV96lf/D9Z7N3GV3vgn2eNTrXUD89k+4w74LpZgcH9dffRJff/fEo6TL6LJx9qgXjR4+X9XN/sHjeofYWryuY9POXa+rHZ0b3odp/sJzOOtXzWx/3GNqf1qKq85bjq3dctq77e7Pzvp0ZWsKC3lr1g5ZYaJIu5QP/eKZ1EDyrJg9qfL6n4db42fq32pMsrrOmn8mA+LhVp7qWeNKgzuy81fo9fd7y9rlnabcOs/sQbMVQnaBIzz4EzQ/VL7/sHB+st9r/Y52gz6Cr1j6U5ycTVedqLSpY1+y8PTcxr/rahSx2lQV6rtpHtnX/Z9+fV/H7P/3l7R3JHqcs9pOVzv4U2rr/s+/PS/icLs/uAoBr+f2f/ipdAEj2nz9KFwCySRcA8kkXAPL9YVG69LxDPLh1uMvu+ivt9i6UrFkmDd8L66eIp259Cby6P/z4txP9fZfySrq4VM8U20mcZbInj2fWB3nPpPFJ4EXtnC4rXSZdEpUNpywhKDJ608+vo9a2BJzJDz/97UR/36XzulYuZ7SfasHyfKvO6Lz3Qmef8RL61zvaz60tmCK4F3A1n9PlFl6dJyfLLzsvcKNFqlqXqqH+Z9cV3H12QM+6yknjhQzVj88M7cOt0DrfPwB4CT/89PeDpMuQzgto/xU5rvN2PCnbU78619D+POqp3zpT1unvZPZ8/wDgJfzw5zOly2g//Vfk2Smqd+kZPHvHoWE99fsfjmV3Gb3p/rOgAeBq/niYdOm5APVM2hrTc9w/bHH92UlvDz8oW1Y/PjO6Dz39BydvD49LeRNwWZN0KS8Ej2daB9Xxk5t6zvc0PDu+LF4et+pUe4snDerMzlut39PnrfG49IzvPF/uRvXW1pfxYOD6qq9dzusaq7gYDwq8oj/95b8u8Pddzt4/wNV8TpdndwHAtUgXAPJJFwDy/ShdAEgnXQDItyZdFrxTyzu7AF7C4nQpP8G34I4AXNOPf12SLkOf047vOztSFAGcT0q6lDeVA+7vzY6/SReA8/opNV1aPy4bPQbg3H76638/PV2Cly8AnFJKurx9mft6ReQAnNVPf1uSLrfBvwezLGmkC8BZ/Xlputzm/kRKEBVlqEgRgEtZky4AUCddAMgnXQDIJ10AyCddAMj3l79LFwCySRcA8v3l7/83N13u7yVWXt9PYrWheY+wDwC7yk2X6icrs4qvkdhJT6nD7gPATrZLl+Bj/FnTLWtsh1LxPgBc35//9t9fbpAu1R8KbXqdjX8MVZ5vje85358u/XcBuJQf//pfG6XL7Uk/EapOWs25YHwwZjRdOu8CcCl//PPfv/wqOV0m/3LPKt4/9Zp0qdZZli5P2QeAQ/ifn/7w5Vf/klUtuCiXtyaavfp3psvocdzP0F0ALuXDx09fZKdL/OXrpEvrS4Dr+/rb77/457R0uT3vcx6PM5ZhULbUanK2zm3w5YtoAV7R199+l5suL6WMLlkCcLvdbl9/+90/SRcAcn39r9IFgGxf/+t3//TP/+PZXQBwLdIFgHzSBYB80gWAfBuly7PelbvRG4IP+1bj/q62fsN0/GGgnbdu0sPiVS/esQV33PkJ9sQ30Jfz9nTylP0Jpu4/2TnLspGzfXYWnF3Okv3fIl2e8pTdeuonLipwnEvYW+Vyii0mbRV87KE8XlBzcfPHeWgms+w/6eO8refJbCfrW138cPQ/pVMe9OC5XR0c9Dk6b7DMJfufmy73B8GtWdPt6bydP9poFfea22bPh9nv7VY/a2pmNflE8eVjh3kn0z1+uXUno/WD3jZtNS4eP4LVPstqwRTJD9Cer106v8/XTNra3/5dq44P7hKPb80btzpbZ8H56mITTZbWM2nQZ89Ewfl7TXlT2UnrpnLenv3vXNpsS8EaZ/up3jc42bM/1fE9U8wuJ56iZ709/be2qOx8ctBaY+e8KX1WS5V93t4/NLP9Vwe0jntd+ydjPTvVuZtvX2bVWVOztd7Zm7Z7aKprSZ+0VSp4sFq9BY9LWbmzzuzjtXJpPfWHHvegydE19swbfDlUakE/ow9H1WyRzgUGBXv6XLOWoSXM9j9Dugw9O4OTnc/m6hStOkNPhWpLs+OzTNayxaQ9W1o9M7vPncWra+w5XrC6ap9B/da64k5agzvnjdc7e2Zo68oBcZ+zK10mrtO5wKDabJ8rFzJUv3Nvmy7zk7Hq1D071bmbb18O7Xj87KnWjO8eD5jtbaP9v9fMTjr0fBjaop7HbkH92efA7P4HRmt2zhu3EQzeYt4F080ODup33jSqf5ahRfX0ObSK+8/6i4z2P+M10+WxmaHxk+PW+B3qjK43OJmiupZ40nL/Z4svOz+7z0H/uY9XoLPO/cHofeNJl63r/t7svEP73Gp1cZ/V4uV+zmqNX7Oozj5Hm+zpc/bk6NT/33bvGVvYUOrU8aPbv5uTM+Vxq3h8vjrFsjplP0GfZbX1lk3a2UlrTHC+3Nuypeq9yjveFz3uZRtxn8HUwXLi8cHs90Jcp9Vnay2zq66uqNpMdd6y8/h8dd74fCzop2ffquODfhZ0uKD/npEDfFZ/Z+nPkvOyFcHV5xS27v/s+/PqpMueqv9U4ZWd/Smxdf9n35+X5u+7AJDP36YEIN/X3373hXQBINfX334vXQBI9s2333/xlXQBINU3H7//cpt08TYPgNf14eOnL7/6VXrZU7yJ8ODtAZzYh4+fvvxlcrq03qJ+qMg5TicAF5SeLm9X7T3T5bHyZIpq1N0Lk+arx2X9ahEAbh8+fvpFXrq0rs47mFz9W0lQbbV6sjW+sz7AS9siXZ7yL/rqRT9oZlm6VOsHBQFe1Id/y0yXR+XVdtO8mU2L0fEr0wjgpb1OurTSojVGugAst1G63B+kFx+aruem1snJQWtweQzw6rZ77QLA65IuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAORbli73nwU3BbcOd7nabLcp9cs6k/OTMeunDu5+kIcgfj6cZd6UR+opz3x4msWvXeLvloNc2nrm3foCtF26LFvUUx6Cp0Raa+oFnaT0L2B4LTunywHtny7BhW9orqNFeOA46fLczanOHjyUcGKf0+XtyR1c/qrfpa1vjPJka3B8oQzKBv2Mzts/dX+d6vnJmfKgehxPXe2zfwnByWrBVjOxVvM9mza5KV5ja7pq/Xuxz+V90/uM7wLX8fbapfxma50sv2x9w5TTDRWJ795znDXvmh7K44me+5bDOlca9z+6rqGJOgev2c/ZGfv3Z/JYTMYEO7/pvsGJHSddeiz+rh5qPph6culZfDwp1TM+XkV8MhgwtK7W+Fnl4KF5g36WzdsaWd3n8syaPof6hxOTLj09jM7bfxzv8+OAeBXBYndYy6zO/c+aNxi/ftPW9Bmc7N9MOIfjpEvnN9j9QX+dlfOOXk16jm8d+/w4IF5FvN7RtdwW7XM5vtXP4r2qTjHU5+OWdm5mf/89fbaKB7PDKU3SpfWNOvmGnBwE312Tb8L4fGfP1cHxt3Qwb6tgq/6tdnHpPD+ZaPH41qJau9Q6jvehWnl2/H3F/gd9Bl3NzhssoX9wa+GdfbaG9dwKp1R97cLF9FwNj+ws/S/r88grguUe35HsWX5hZ3+Iz9L/WfqEzfk9YwDkky4A5JMuAOSTLgDkky4A5FuTLgveHuPtNAAvIeU38C8ImAUzAnAaa/42ZevLofvOjhRFAOeTki7lTeWA+3uz42/SBeC8ctOl9eOy0WMAzu0I6RK8fAHglHL/3yX39YrIATir3PeM5f5kTLoAnFX6511aP+Z6PFmGihQBuBSf1Qcgn3QBIJ90ASCfdAEgn3QBIJ90ASCfdAEgX3q63N9LrAzAaeSmS/WTlVnF0x25N4Bz2y5dgo/xZ023xnE6AbigjdIl/iUxWdNVK/f8Zpp7YdJ/9bisXy0CwIbpctv39UEZbLd2WrR66xnfWR/gpW2RLtWL79aq894Lk/HVItUBQf2gIMCL2ihdHr9s3ZprNi1Gx69MI4CXtud7xp6bLq3eWmOkC8By1/i8SzBjz02tk5OD1uDyGODV+aw+APmkCwD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD5lqXL/WfBTcGtw12uNtttSv2yzuT8ZMyaqeN9Dorv/BDM9nmKedfXedYzH55m8WuX+LvlIJe2nnm3vgBtkS5BzdnKT3kInhJprakXdJLSv4DhteycLge0f7rEwTA6V/XqebTNP066PHdzgn8KHO0hg7U+p8vbkzu4/FW/S1vfGK1LXv/5qs5+Ruftn7q/TvX85Ex5UD2O+6zO27+E4GRQP5glmHqomdb4eI2t6ar178U+l/dN7zO+C1zH22uX8putdbL8svUNU043VCS+e89x1rxreiiPJ3ruWw5rNT+7nNaAof3smahz8Jr9nJ2xHDm7nOodJ2fW9Dm0b3Bix0mXHou/q4eaD6aeXHoWH09K9YyPVxGfDAYMras1flY5eGjeoJ9l87ZGVve5PLOmz6H+4cSkS08Po/P2H8f7/Digv+14RVusZVbn/mfNG4xv3b1/09b0GZzs30w4h+OkS+c32P1Bf52V845eTXqObx37/DigZ3xrvaNruS3a53J8q5/Fe1WdYqjP6h5Wl7Og/54+W8WD2eGUJunS+ka9N65uwfjJTT3nO3uuDo6/pYN5WwVb9W+1i0vn+clEi8e3FtXapdZxvA/VyrPj7yv2P+gz6Gp23mAJ/YNbC+/sszWs51Y4peprFy6m52p4ZGfpf1mfR14RLPf4jmTP8gs7+0N8lv7P0idszu8ZAyCfdAEgn3QBIJ90ASCfdAEg35p0WfD2GG+nAXgJKb+Bf0HALJgRgNNY87cpW18O3Xd2pCgCOJ+UdClvKgfc35sdf5MuAOeVmy6tH5eNHgNwbkdIl+DlCwCnlPv/LrmvV0QOwFnlvmcs9ydj0gXgrNI/79L6MdfjyTJUpAjApfisPgD5pAsA+aQLAPmkCwD5pAsA+aQLAPmkCwD50tPl/l5i5fX9JFYbmvcI+wCwq9x0qX6yMqv4Gomd9JQ67D4A7GS7dAk+xp813bLGdigV7wPA9W2ULtUfCm16nY1/DFWeb43vOd+fLv13AbiU7dLl9qSfCFUnreZcMD4YM5ounXcBuJQt0mXyL/es4v1Tr0mXap1l6fKUfQA4hI3S5fHL1q2JZq/+nekyehz3M3QXgEvZ8z1jr5YurS8Bru8yn3d5nLEMg7KlVpOzdW6DL19EC/CKfFZ/jTK6ZAnA7SZdANiCdAEgn3QBIJ90ASCfdAEgn3QBIN9G6fKsd+V6TzDAIWyRLs+9vksXgOfb9LdYtm7Nmi7oYdMpAJix52uXTdOl+mn52WM/SQPYxDV+MjaUKLM3AbCWdClvAmCta/xkTLoAHIt0CRoGYKHt3jO28yX7ccYyOYLzogUg38t+Vl+oAGzoNdPFqxaAbb1mugCwLekCQD7pAkA+6QJAvg8fpQsA2dLTxduxYvYHeAkfPn76MvvTlOXxMe3f3rn2B2C5PdPlUP9mf0on0gV4FR8+fvryq03+32XndGn9xKl6/l7oHH9r/L6yBeuSLsCVfbNNujzx0tl6fVBNhc77Pn7ZSpqhJYsW4OK++fj9l1/9S27Np1w649cirfHBydZrlFstacp5Z1vtWxbAOX3zbXK6BJfOoUvw4klnY6NzWE9KLViOaAFewjfffv9FXrrEV/n906UnLUbH98w72ifA1WyRLo+yKvdPfatdxINsaEVgGS1xkZ7FPnF/AHaVmy58VqaILAFei3QBIJ90ASCfdAEg3zfffvpim8/qA/C6pAsA+aQLAPnS0+Uab8A9e/8AT5abLuXHGLMq76z1wckntPK8eQGW2+4nY8HH4LeYbmvP6vy8Owa8tO3ekbxnugSfip892WoyGN9f/1bsw1A/ifMC7GqLdKletTf1eEmdfHmv/aSudVwWDM7EdSY9LO4nZV6Ave352mU7h02Xaj+POutU5y3rtOYF2NuVfjJ2O166zJbNrRPfBLCfi/19lx3SpbPOUBr11FkzL8De0l+73B8klu2ZtPpltZ/Zq3Nwr3sjMltFqq3295M1L8Cu0v/yMQDcvvkoXQDI9s3HT1/6PWMA5PogXQBI9+Hjpy9/KV0ASCVdAMj34eOnX0gXAHJtly4H+dRF7kdA+kv56Anw0jZKl6NdWBOb6SkVfzoS4Po+/Ft+urT+2f7EyJEuALtKT5e3i+nO6RL/JCpoZsH5oSVIF+AV5abLEf7NXp13crKnz9aYoXWJFuBFbZEui/+Znzh19dbql9WbJnWWpYtoAV7XFv/v8ll5bd0ub2av/p3pMnrc2RLAy5EuW6TLgjQCuJSN0uX+IL14POOtdnEv+2l1OFvn1hEYrUkBXsV2r11eQZkisgTgdpMuAGxBugCQT7oAkE+6AJBPugCQT7oAkG/r3wSTVXlnR2v+aP0AzNjut1ieWnUhT1za0foBmLFnupz6Bc3ROj9aPwDvXCNdgp/IzZ68N34TTDC+v/6t2JNgfPXL0X4ADmHT/3fJKts57+3nHxZVr+w9x2XB4ExcZ9JD3E+r59F+AI5iz9+RvJ3Dpku1n0dlteqmSRfgZC72G/iPli6zZctbpQtwBXv+5eNrpEtnncVptKYfgKNIf+1yf5BYtmfS6pfVfmav8sG9qlf5oEi11aCfoP+efgAOwWf1AcgnXQDIJ10AyCddAMgnXQDIJ10AyCddAMi3Rbr4HMZiwabZUuBMNvo0ZWLB7Rytz2DrBDZwMtf4DfwLHKeT29wvOIhvBTiiy6TLY/HWb1IpB8c3bdFnoDppdVEAR3exv+/SeVx+OTt+B+WMz+0HYLk9f0fydq6dLs/KbIDlLvYb+DuPq+3F43cQzyhagDO5Rrrcin/mz/bz9mXn+B1IF+A6rvH3XcoGevqpnn9K//dCMGC3rgCWu8Zn9Z/7mgOAqWuky82/7gEO5TLpAsCBSBcA8kkXAPJJFwDySRcA8l3v8y4HZ3+Al3CN3zO2zP7tnWt/AJa7zG+CGfX0Tp7eAMCGLpMurZ84Vc/fC53jbyO/aaan4aG7AJzGpv/v8pSrZyvhqqnQed/HL1tJ07/eJ24OwE42es/Y/lfPVqq1OlmWLpNQuRdGG+4fD3Ame6bLdv9mn30NUZ5cli6zZZf1DHA1W6RL/HJhz3TpSYvR8T3zjvYJcDXb/b9LYs3RecuLeJAN99prmmq0xEU6lzw6HuCUfFZ/C/eGZ/cFsBfpAkA+6QJAPukCQD7pAkA+6QJAPukCQL7tPqtfnnnKe3NzJ+0v5Y3IwEvb57P61Q8n5k462tKmpR7HCBjgFW3xG/jjdCkH7PBvfOkCsKudX7tU4yclXeKfRLVaWnZ+qFXpAryi/dOlOmDT2cuTPa8tWmOGmhctwIvaM10eMyb9mhu/tuhPl2qdZekiWoDXtXO6VAe0ImHZjGvSZfS4syWAl3OE94xdL10WpBHApWz3nrFWhGx0tX2sXF7cy6lbzczWuXUERrAPAC/BZ/XXKFNElgDcbtIFgC1IFwDySRcA8kkXAPJJFwDySRcA8u32913i80dztDcWH60fgBn7fFY/Pn9A1Vaf2PzR+gGYseffd4lT5+DXyqN1eLR+AN45wmuX9ekSfFp+9mRPEC6uX646GF/9crQfgEM4Qrokzji5oJeX6fg4aHV2WCshHgOgf/yyfgCOQrpsmi7Vfh6V1Tq3TroAh3aEdAmuqqMzHi1dZsuWt0oX4Aqky2i6dNZZnEZr+gE4in3+vkvrfO681S+rk85e5YN7Va/yQZFqq0E/Qf89/QAcgs/qA5BPugCQT7oAkE+6AJBPugCQT7oAkE+6AJBvt7/vEnwEZFO58/aXetZ6AQ5hn8/qlx8PzJ1xQUublnr6egGebM+/71IeT+6V1UarsaeUki7AK9rz94y1bk1Jl/gnUcGkC85LF4AZO6fLDpfa6hSTk/FrqXhM/xJSUhPglI7wO5ITJ21d0PvTpVpnWbosGw9wBbuly+wLmjWX4Nmrf2e6jB6P9gbwKo7wnrHrpcuaNAK4gmv8fZfb+4jqmbrVzGyd20jAiBbgRfms/hpldIkTgNtNugCwBekCQD7pAkA+6QJAPukCQD7pAkC+y/99l6rjdAJwTUf4rP7WqtNJF4AN7fP3Xcox1XtltRFPF58HIMG1/75L8Cn6ty/L11Xl+bh+sDSAF7X/b+Df+vrbecVvBcnkZDCgfy6Al3OE1y6Jk86+vKieL48noTKbLuUwgJd2hHQpI2HNjCnpMjpYugC8c4T3jO2TLkHqLE6XoD7AS9vn77tMbsqarjr1rREAwZnJHYOAKW+SLgAVPqsPQD7pAkA+6QJAPukCQD7pAkA+6QJAPukCQL7d/r7L400+FwJwcTv/JphNP1A56iBtAFzQnn/fJf64+87X+uOEHMAF7fbaJfiNKevT5bHCpFQ10u6FsvPyuKxfLQLAIX6LZe6kcRIETXaO76wP8NL2TJdN/6VfvegHky5Ll2r9oCDAi7rG33dpTRqUXZYu/eMBXtrrpEsrLVpjpAvAcrv9fZdyQNakcdmem1onJwetweUxwKvzWX0A8kkXAPJJFwDySRcA8kkXAPJJFwDySRcA8i1Ll/JzLQf5qMdBOgn25Gg7BrCJxa9dJtfHPa+VwVybXrWHKsedSBfg4rLSZTdnmTcxXbzWAc4nJV1avw2l/EUp5VWyev7ty8lN90JcJ67ff9VeOW85RWefk5tm+wQ4ipXp0rra3mrR0n/cP6za1VCRzgv37LDOqRcMBjif3Ncujze1rp7VkfFdjpwuo/0HfVbrAJzSFv/vMpous/UPmy5BnQXpEk8tcoAzSX/P2Nv50Sv7aDDMXu6XzTu73pX9Lx7c0yTAUeR+3mX2ohlcOoPzPVfbaj+t+vHVfHbVrZOtg3Lqzj4Bzuqwn9V3nQU4sWOmi3/IA5zbMdMFgHOTLgDkky4A5JMuAOSTLgDk2yJdvN0L4NWlp0v5icLD2rq9Zy1/dN6DP0zAKW2XLge3dZ/P2ofRec/yeAEns0+6VH9dyuSmnl+Xktvk7NS71e/Zn8lNKfs22+fkeHIwuy7gdeWmS3Bpq16YqpewyeDbNv++rtZs9ZNVPxiwbH+COiv7HJo6cd+Ai9jtJ2PVi2bPZSuomd5n4lVydh+qqTC0P0GdrD47j4N+gPuSPIcAAAZzSURBVBe1c7oEJ1uXraBmep+tfnaov2x/Oucd7bNz6seHSaIA70iXBVfwLerH+/amv05n/8H4ct7W1In7BlzEdv/v0nO+dVPnlTer285Wc+vfiqtzPGl1T+ItXdNnz7yd/QCvyGf1j+zxYv2UC3crHXduAzgf6XJwT3lN0JrUCxSgl3QBIJ90ASCfdAEgn3QBIJ90ASDfcdLlOO9EOtTborxNCzilg6TLcS6gB2njs6d/3gVgoSOky3H+eX6EHh5JF+Csnp4ubxfNI1w9j9DDox3SpRrt9/d2bgm4guemy9EuVcFV9Vl2a6n1WFSDp3oTwD8cIV2Oc00/7KVzu2aqmy9dgLWe/pOxN0e4VB320rlRMz2JIl2AJaRLq4cj9PPZ1i9c+o8fzxxnf4AjOki6HOeCdZxOPtu6mcf65cGtnW3H2SLgiA6SLpyLaAFmSBf6He2FHXBc0gWAfNIFgHzSBYB80gWAfNIFgHxPT5fnvg2pnPRob4s6Wj8AXY7we8bK4/1nP0I/paP1A9DrNdOl9YLgaFfzo/UD0Os106VnxiNczXfYn2rQ3t/buSXgCg71/y7HSZfjXDd3259WbFSDp3oTwD88PV0+e8p1qjXpAS+a27VUTS/pAqwlXY7QyayNuupJFOkCLHGEdHnWRaqc95iXzq1fuPQfP545zv4AR/T0dHnKdepeiM8/0dadPNYvD27tbDvI/gAH9fR04YxECzBDutDvUK/qgEOTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAOSTLgDkky4A5JMuAORbli73nwU3BbcOd7mXoPMtJsqqs13Ds49ySv2yzuT8ZMyaqePnZ1B856fubJ+nmHd9nYNfMYgsfu0SP+oH+RZd4FzpkltqqPjWF6At0iWoOVv5KU/dp0Raa+oFnaT0f/yLBnU7p8vxna7zZzW8f7rEwbB+3gM+9MdJl+duTvBPgaM9ZPzD53R5e5CCb+Pqs631ALe+dfvPt8R1JsdBk7N1yoLl+Vad0Xnvhc4+qzeVyrUM1V8874I61fOTM+VB9Tjuszpv/xKCk0H9YJZg6qFmWuPjNbamq9a/F/tc3je9z/guHNHba5fySdM6WX7ZeuDL6YaKxHfvKdUaP1snuPvsgJ51lZPOrnGofjDdyj6H5l3TQ3k80XPfctjt/SPYWmnc/+i6hibqHLxmP2dnLEfOLqdnV9f0ObRvHMJx0qVTT+XZ/oN547tMyi7+bhnan0dDa+lcVH+fo/OWS1jWz9vxpFTP+AVLCxaybF2t8bPKwUPzBv0sm7c1srXPwSaP9jnUP4dwunTpmXG2/2Deobss/m7p3LGebezZw6w+t563//ienS6zK9piLbM69z9r3mB86+79m7amz+Bk/2ayt+Oky8pn/+3h2Tb0DF7wDTA0ePaO1S9X1i+Vm7Oyz5551zwWwVxvX86OnwwbXe/oWm6L9rkc3+pn8V5Vpxjqs7qH1eUs6L+nz1bxYHaebJIurSfcvfFdGoyf3NRzvqfh2fFl8fK4VafaWzxpUGd23mr9nj5vjccl1t9/0NLovK3xQ+ere7JyfKvzcnB5HO9Dtfjs+PuK/Q/6DLqanTdYQv/g1sI7+2wN67mVJ6u+djmva6yCg+i5Gh7ZWfpf1ueRV8Tt9v4dyed9tM7eP4d19qfWWfo/S58M8HvGAMgnXQDIJ10AyCddAMgnXQDItyZdFrzNw9tCAF5Cym/gXxAwC2YE4DTW/G3K1pdD950dKYoAziclXcqbygH392bH36QLwHnlpkvrx2WjxwCc2xHSJXj5AsAp5f6/S+7rFZEDcFa57xnL/cmYdAE4q/TPu7R+zPV4sgwVKQJwKT6rD0A+6QJAPukCQD7pAkA+6QJAPukCQD7pAkC+9HS5v5dYGYDTyE2X6icrs4qnO3JvAOe2XboEH+PPmm6N43QCcEEbpUv8S2KypqtW7vnNNPfCpP/qcVm/WgSADdPltu/rgzLYbu20aPXWM76zPsBL2yJdqhffrVXnvRcm46tFqgOC+kFBgBe1Ubo8ftm6NddsWoyOX5lGAC9tz/eMPTddWr21xkgXgOWu8XmXYMaem1onJwetweUxwKvzWX0A8kkXAPJJFwDySRcA8kkXAPJJFwDySRcA8kkXANL9P2+edoGYfbJQAAAAAElFTkSuQmCC" alt="" />

在字节码里可以看到，用synchronizde修饰的同步代码块多了两个指令：monitorenter、monitorexit；

代码块同步是使用monitorenter、monitorexit指令实现的，而方法同步是使用另外一种方式实现的，但是方法同步也可以使用这两个指令来实现。

monitorenter指令是编译后插入到同步代码块的开始位置，而monitorexit是插入到方法的结束和异常位置。任何一个对象都有一个monitor与之关联。线程执行到monitorenter指令处时，会尝试获取对象所对应的monitor所有权，即尝试获得对象的锁。

二、修饰普通方法 锁是当前实例对象

我们先来看下将实例对象作为锁的概念：

public class AddNumTest
{
    private int num = 0;

    public synchronized void addNum(String str)
    {
        try
        {
            if ("a".equals(str))
            {
                num = 10;
                System.out.println("add a");
                Thread.sleep(2000);
            }
            else
            {
                num = 20;
                System.out.println("add b");
            }
            System.out.println(str + " num = " + num);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

public class AddNumThreadOne implements Runnable
{
    private AddNumTest at;

    public AddNumThreadOne(AddNumTest at)
    {
        this.at = at;
    }

    @Override
    public void run()
    {
        at.addNum("a");
    }
}

public class AddNumThreadTwo implements Runnable
{
    private AddNumTest at;
    public AddNumThreadTwo(AddNumTest at)
    {
        this.at = at;
    }

    @Override
    public void run()
    {
        at.addNum("b");
    }
}

public class AddNum
{
    public static void main(String[] args)
    {
        //注意，这里传入同一个实例对象
        AddNumTest at = new AddNumTest();
        //AddNumTest bt = new AddNumTest();
        Thread t1 = new Thread(new AddNumThreadOne(at));
        Thread t2 = new Thread(new AddNumThreadTwo(at));
        t1.start();
        t2.start();
    }
}

执行结果：

add a
a num = 10
add b
b num = 20

前面解释过关键字synchronized的实现原理是使用对象的monitor来实现的，取的锁都是对象锁，而不是把一段代码或者函数作为锁。在并发情况下，如果并发情况下多线程竞争的是同一个对象，那么先来的获取该对象锁，后面的线程只能排队，等前面的线程执行完毕释放锁。

上面介绍的是同一个对象锁，我们来观察下获取不同的对象锁会是什么情况：

public static void main(String[] args)
    {
        //注意，这里传入的不同的实例对象
        AddNumTest at = new AddNumTest();
        AddNumTest bt = new AddNumTest();
        Thread t1 = new Thread(new AddNumThreadOne(at));
        Thread t2 = new Thread(new AddNumThreadTwo(bt));
        t1.start();
        t2.start();
    }

执行结果：

add a
add b
b num = 20
a num = 10

这里线程1、2抢占的是不同的锁，尽管线程1先到达同步代码块的位置，但是由于monitor不一样，所以不能阻塞线程2的执行。

三、synchronized锁重入

锁重入：当一个线程得到一个对象锁后，再次请求此对象锁时可以再次得到该对象的锁。但是这里有维护一个计数器，同一个线程每次得到对象锁计数器都会加1，释放的时候减1，直到计数器的数值为0的时候，才能被其他线程所抢占

public class AgainLock
{
    public synchronized void print1()
    {
        System.out.println("do work print1");
        print2();
    }

    public synchronized void print2()
    {
        System.out.println("do work print2");
        print3();
    }

    public synchronized void print3()
    {
        System.out.println("do work print3");
    }
}

public class AgainLockTest
{
    public static void main(String[] args)
    {
        Thread t = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                AgainLock al = new AgainLock();
                al.print1();
            }
        });
        t.start();
    }
}

执行结果：

do work print1
do work print2
do work print3

这里面三个同步方法，使用的锁都是该实例对象的同步锁，同一个线程在执行的时候，每次都是在锁没有释放的时候，就要重新再去获取同一把对象锁。从运行结果可以看出，关键字synchronized支持同一线程锁重入。

四、synchronized同步代码块

用synchronized同步方法的粒度过大，有时候一个方法里面的业务逻辑很多，但是我们想对同步的部分进行单独定制，这时候就可以使用synchronized来同步代码块。

public class SynchronizedTest1
{
    public void doWorkTask()
    {
        for(int i=0;i<100;i++)
        {
            System.out.println("nosynchronized thread name =" + Thread.currentThread().getName()
                + ";i=" + i);
        }
        synchronized(this)
        {
            for(int i=0;i<100;i++)
            {
                System.out.println("thread name =" + Thread.currentThread().getName()
                    + ";i=" + i);
            }
        }
    }
}

如果在并发情况下，调用这个类的同一个实例，线程A和B可以同时执行使用synchronized同步之前的代码逻辑，但是使用关键字同步的部分是互斥的，先到达的线程占有对象锁，后面的线程会被阻塞，直到对象锁被前面的线程释放。

四、总结

synchronized是一种悲观锁：

1、多线程竞争的情况下，频繁的加锁解锁导致过多的线程上下文切换，由于java线程是基于操作系统内核线程实现的，所以如果阻塞或者唤醒线程都需要切换到内核态操作，这会极大的浪费CPU资源。

2、一个线程持有锁，会导致后面其他请求该锁的线程挂起。

synchronized锁优化：自旋锁

很多应用*享数据的锁定，只会持续很短的时间，如果因为这很短的时间做线程的挂起和恢复，会造成很大的性能消耗（因为java线程对应操作系统的内核线程），让当前线程不停地的在循环体内执行不被挂起，这就是自旋锁的实现，后面会展开详细介绍。