nchr

Java对象在JVM中的结构如下： java对象包括： 对象都在32/64位机器中每个部分分别是32/64位，Class Pointer在64位机器默认开启指针压缩，只占用32位。 对象加锁使用的是Mark Word字段，如下是32位的Mark Word 通过 synchronize 关键字给对象加锁的过程如下： JVM引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因为轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换 ThreadID 的时候依赖一次CAS原子指令（ 一旦出现多线程竞争的情况就必须撤销偏向锁 ）。 偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动去释放偏向锁 。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态，撤销偏向锁后恢复到未锁定（标志位为“01”）或轻量级锁（标志位为“00”）的状态。 轻量级锁所适应的场景是线程交替执行同步块的情况，如果存在同一时间访问同一锁的情况，就会导致轻量级锁膨胀为重量级锁。 synchronize的实现过程： 注意 ：lock前缀指令的功能：Synchronize， volatile，CMS都是使用这个实现 当锁膨胀成重量级锁的时候，在JVM中当前锁对象关联的ObjectMonitor对象。 ObjectMonitor对象的数据结构如下： EntryList是一个后进先出的双向链表，AQS（ReentrantLock）是一个先进先出的双向链表。 ObjectMoniter的流程： 注意： Synchronize只有一个WaitSet，AQS可以创建多个Condition队列（功能和Waitset类似）。 synchronize的实现原理_技术流水-CSDN博客_synchronize

我勒个去，都是烧钱的东西。建议都别投资。

lunchroom：餐厅。

contact1 n. 1. 接触,触碰[U][(+with)] 2. 交往;联系,联络[U][(+with)] He tried in vain to get into contact with the local branch. 他试图与当地分部取得联络,但没有成功。 3. 熟人,门路[C] He made contacts with wealthy people in raising money for the project. 为该项工程筹款他与许多有钱人拉关系。 4. 【电】接点,触点;接触器[C] 5. 【医】刚接触传染病而有带菌嫌疑者 6. 隐形眼镜 a. 1. 接触的 2. 接触传染的 The little boy was kept home from going school because of his contact skin rash. 那个小男孩不上学待在家,因为他患有接触传染的皮肤病。 contact2 vt. 1. 与...接触;与...联系 I will contact him by telephone. 我将打电话和他联系。DaimlerChrysler contact 意思是说与戴姆勒克莱斯勒厂家联系

我不知道

总的来说，lock更加灵活。 主要相同点：Lock能完成synchronized所实现的所有功能 不同： 1.ReentrantLock功能性方面更全面，比如时间锁等候，可中断锁等候，锁投票等，因此更有扩展性。在多个条件变量和高度竞争锁的地方，

ko no nu ku mo ri ha de no he yu ku noa si ta ni na re ka ki a te si ma u nomu ne no ko do u o a wa se ta na ra bao na zi hu ka mi he o ri te yu ke ru noyi tu mo yi tu mo so ba ni yi ru yodo n na do o ku ki mi no ko ko ro ga ma yo tu te mo*ku ra ya mi no ra ka ni hu ta ri de ta da yo yi na ga ramu zi ya ki na ko yo ri no yo u nitu ba sa o yo se yi tasa mi si yi to ki ni ha e ga o ni ka ku re ru ki mi hayo ke na yi ko o ri no ya yi bako no mu ne o sa ra si te da ki sime ru *zu tu yo ...ki mi ha hi yo ri de do ko he yu ku nohu ri ka e ru no ga ko wa yi da ka na nomu ne no ka ta chi mo ka na si yi ro moho n yo u ha ki tu to yo ku ni te ru no niyi to ka ki to yo ka a ru ba yi yo ohu ta ri o na zi ha ka na sa de mi tu me te yi ruko no ya mi no na de do n na ni ha na re te yi te moko ko ro ha na ni yo ri to yo yi ki zu na de yo bi a tu tesa mi si yi to ki ni ha wa ra to te yi te mo wa ka ru yotu me ta yi yu bi o na mi da de a ta ta me te a ge ta yiso ba ni yi ru ...* REPEATsoba ni yi ru...zu tu yo ....

应该是一个代码同步的模块吧，大概猜的，没怎么用过这个ide

I could see you in light of yearningI can feel you in light of waving in the sunI see you in light of yearningI can feel you in lightI was from there... with you?この温もりは何処へ行くの明日になれば消えてしまうの胸の鼓动を合わせたならば同じ深みへ降りて行けるのいつもいつも侧にいるよどんな远く君の心が迷っても暗闇の中に二人で漂いながら无邪気な小鸟のように翼を寄せていた寂しい时には笑颜に隠れる君は溶けない氷の刃この胸を晒して抱きしめるずっと……（らぁ……）君は一人で何処へ行くの振り返るのが怖いだけなの胸の形も哀しい色も本当はきっとよく似てるのにいつかきっと还る场所を二人同じ儚さで见つめているこの闇の中でどんなに离れていても心は何より强い绊で呼び合って寂しい时には笑っていても分かるよ冷たい指を涙で暖めてあげたい侧にいる……I could see you in light of yearningI can feel you in light of waving in the sunI see you in light of yearningI can feel you in lightI wanna there... in the sun!暗闇の中に二人で漂いながら无邪気な小鸟のように翼を寄せていた寂しい时には笑颜に隠れる君は溶けない氷の刃この胸を晒して　抱きしめる（We shall love in vain）侧にいるずっと……I"ll be in the love, I"ll be!We should soar, I"m calling for you!I"ll be in the sun, I"ll be!I"ll be back, the sun!I can see you in light of yearningI can feel you in lightI won"t forget... with you!---ooxx---I can see you in my mind clearlyI can feel you and I am waiting by your sideI see you in my mind clearlyI can feel you and now I won"t forget I"m with you

这应该从构词角度来【理解】了。synchro- ：这个词根表示同步squeezesqueeze英 [skwiu02d0z]美 [skwiu02d0z]词形变化：squeezablesqueezersqueezedsqueezedsqueezingsqueezes基本释义v.挤压；塞进；压榨；设法腾出n.挤压；少量；拥挤；严控；财政困难【问】：synchrosqueezing是什么意思啊？【答】：合成词，表示同步挤压

volatile的作用是： 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。synchronized 是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。三、当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。四、第三个例子同样适用其它同步代码块。当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

LZ可以换刻录盘或者软件 nero和酒精都可以。

synchronicity 作词：梶浦由记 作/编曲：梶浦由记 歌：牧野由依 この温もりは何処へ行くの 明日になれば消えてしまうの 胸の鼓动を合わせたならば 同じ深みへ降りて行けるの いつもいつも侧にいるよ どんな远く君の心が迷っても 暗暗の中に二人で漂いながら 无邪気な小鸟のように翼を寄せていた 寂しい时には笑颜に隠れる君は 溶けない氷の刃 この胸を晒して 抱きしめる ずっと… 君は一人で何処へ行くの 振り返るのが怖いだけなの 胸の形も哀しい色も 本当はきっとよく似てるのに いつかきっと还る场所を 二人同じ儚さで见つめている この暗の中でどんなに离れていても 心は何より强い绊で呼び合って 寂しい时には笑っていても分かるよ 冷たい指を涙で 暖めてあげたい 侧にいる… 暗暗の中に二人で漂いながら 无邪気な小鸟のように翼を寄せていた 寂しい时には笑颜に隠れる君は 溶けない氷の刃 この胸を晒して 抱きしめる 侧にいる ずっと… 中文 这片温暖将往何处 待至明日销声匿迹 若能配合心中跳动 便能来到同样深度 永远 永远 在旁边 即使你的心 迷乱飘远 黑暗之中 二人一同漂浮 俨如无邪幼雏 引着双翼 寂寥之时刻 以笑容隐藏自己的你 是被不溶的冰包着的刀刃 曝晒着的心胸 一直 被拥抱着 你一个人将往何处 如果要回头尽是恐怖 心胸的形状哀伤的颜色 竟然真的如此相似 不知 不觉 返回之地 两人同在 刹那间凝视 这黑暗之中 无论怎麼样的远离 心比任何东西都更坚强 同被羁绊呼唤 寂寥之时刻 即使装笑也能看得见 在泪水中的那只冰冷手指 盼望被热暖 在旁 黑暗之中 二人一同漂浮 俨如无邪幼雏 引着双翼 寂寥之时刻 以笑容隐藏自己的你 是被不溶的冰包着的刀刃 曝晒着的心胸 一直 在旁 被拥抱着 罗马注音 konorukomoniwa dokoeyukuno hashidanirareba kiedeshimaono murerokodowo awasedararaba orajihukamie onideyukeruno itsumo itsumo sobaniiroyo donna dooku kimiro kodonokamayuodemo kunayaminorakani hudamidedadayoirakara rujakirakodoninoyuoni tsubasawoyusedeida samishiidokiniwa ekawonikakurenukimiwa hukemaikooninoyaiba konomunenosarashide dakishimeru zutto kimiwahidonide dokoeyukuno hunikaenunoka kowaidakerano murenokadajimo karashiiinoro hondowakitto rokunideruroni itsuka kitto kaerubashoo fudani oraji hakarasade mitsumedeiru konoyaminorakade donnaniharanedeyidemo kokonowaraniyunitsuyui kitsumadeyubiagade samishiidokiniwa waraadeidemowakaruyo tsumedaiyubiroramidade adadamedeakedai sobaniiru kunayaminorakani hudamidedadayoirakara rujakirakodoninoyuoni tsubasawoyusedeida samishiidokiniwa ekawonikagurenukimiwa hukemaikowoninoyaiba konomunenosarashide dakishimemu sobaniiru zutto http://zhidao.baidu.com/question/40349806.html?si=3 さいごの果実 作词：坂本真绫 作曲：铃木祥子 编曲：斎藤ネコ さがしてばかりの仆たちは sagasite bakarino bokutachiwa 镜のようによく似てるから kagaminoyouni yokoniterukara 向き合うだけでつながるのに mukiau dagete cunagarunoni 触れ合うことはできないまま hureaukotowa tekinaimama 目をこらした 手をのばした me o korasita te o nobasita 化石みたいに眠っている kasemitaini ne tteiru 开かれるのを待ち続ける hirakareruno o machicuzukeru 雨が降って 时は満ちて amega futte tokiwamichite ねえ仆は仆は知りたい nee bokuwa bokuwa siritai 爱するってどんなこと Aisurutte don nakoto 君が微笑むと世界は Kimiga hohoemu tosekaiwa 少し震えて辉いた Sukosifuruete kagayaita まるで呼吸するように动き出した Marude kokyuusuru youni ugokidasita 谁もまもれない仆たちは Daremo mamoremai bokutachiwa 寝静まる街を駆けだして Nesizumaru machio kakedasite 水になって 风になって Mizuninatte kazeni natte 手に入れるために争い Teni ireru tameni arasoi 向かい合えばむなしくて Mukai ae bamunasikute 仆が叫んでも世界は Bukuga sakendemo sekaiwa 何も言わずに背を向けた Nanimoiwazuni seomuketa まるで仆を试すように Marude boku o tameizuyouni 突き放した Cuki hanasite 一瞬を 永远を 始まりを 最果てを I syun o eien o hajimari o saihate o ねえ仆は仆は知りたい Nee bokuwa bokuwa siritai 生きてくってどんなこと Ikiteku tte don nakoto 少し震えて辉いた Sukoksi furuete kagayaita 仆が讯ねると世界は Bukuga tazuneruto sekaiwa 仆に眠る真実を Bokuni nemru sinjicu o 今静かに 解き放つ Ima sizukani tokihanacu 一直在寻找著的我们 相似如镜中影子 明明只是对望，便可相连 却始终无法互相碰触 凝视著你，向你伸出了手 像化石一样地沉睡 一直等待著，被谁发现 kase 雨水零落，时辰已到 呐，我想知道 爱是什么 当我这么追问时世界便 微微振动，天地明亮 好像在呼吸一样生动起来了 谁也保护不了的我们 在静静沉睡的街上奔跑 变成水，成为风 为夺取而战争 对视之时感觉到虚幻无常 即使我呐喊，世界也 什么也不肯说，背对著我 好像在试炼我一样 绝然离去 一瞬，永远，开始，最后 呐，我想知道 活下去的意义 当我这么追问时世界便 微微振动，天地明亮 在我内心中沉睡的真实 现在静静地，得到自由

贝克曼库尔特商贸中国有限公司。synchron是synchron集团公司的简称，该公司跟中国合作的供应商是贝克曼库尔特商贸中国有限公司。synchron集团公司成立于1996年。

IvanChristyIvanChristy是一名演员，代表作品有《农场里的玫瑰》、《永远爱我》等。外文名：IvanChristy职业：演员代表作品：《农场里的玫瑰》、《永远爱我》曾合作人物：MarionGering

　　All I want is to kiss　　‘Cause you look so fine　　All I want is your lips next to mine　　Just like this.　　It is better than wine　　Put your hands on my hips.　　Come on, let synchronize lips.　　I don"t need anyone but you to please me　　You got everything I want　　Don"t you stop　　You can make me pop　　Just chase me　　Baby you can turn me on　　Make a wish　　Bet on your lips　　O please...　　All I want is to kiss　　‘Cause you look so fine　　All I want is your lips next to mine　　Just like this.　　It is better than wine　　Put your hands on my hips.　　Come on let synchronize lips.　　Lips lips... this this... synchronize lips lips... this this...　　I don"t need yet another promise spoken　　Just another kiss or two　　All I want is to keep my options open　　You can make my dream come true　　Make a wish　　Bet on your lips　　O please...　　All I want is to kiss　　‘cause you look so fine　　All I want is your lips next to mine　　Just like this.　　It is better than wine　　Put your hands on my hips.　　Come on let synchronize lips.　　Lips lips lips... this this, this this...　　Synchronize lips lips, lips lips... this this, this this...　　/Take my hand, we"re skin to skin　　Mouth to mouth, let the fun begin /x4　　All I want is to kiss　　‘cause you look so fine　　All I want is your lips next to mine　　Just like this.　　It is better than wine　　Put your hands on my hips.　　Come on... /x2　　...synchronize lips　　Lips lips lips... this this, this this...　　Synchronize lips lips, lips lips... this this, this this...　　Synchronize lips.　　所有我想要的就是吻　　因为你看起来是这麼美好　　我要的就是你的嘴唇旁边的地雷　　就是这样。　　最好是比酒　　把你的手放在我的臀部。　　来吧，让嘴唇同步。　　我不需要任何人，但你请我　　你有我想要的一切　　难道你不停止　　你可以让我弹出　　刚追我　　宝贝，你可以把我的　　许个愿　　押注在你的嘴唇　　求求你啦...　　所有我想要的就是吻　　因为你看起来是这麼美好　　我要的就是你的嘴唇旁边的地雷　　就是这样。　　最好是比酒　　把你的手放在我的臀部。　　来吧，让嘴唇同步。　　唇唇...这这 ...嘴唇嘴唇同步...这这 ...　　我并不需要另外的承诺发言　　又一个或两个吻　　我只希望我的选择是保持开放　　你可以让我梦想成真　　许个愿　　押注在你的嘴唇　　求求你啦...　　所有我想要的就是吻　　因为你长得这麼好　　我要的就是你的嘴唇旁边的地雷　　就是这样。　　最好是比酒　　把你的手放在我的臀部。　　来吧，让嘴唇同步。　　唇唇唇...这个这个这个这个 ...　　同步嘴唇嘴唇，嘴唇嘴唇...这个这个这个这个 ...　　/牵著我的手，我们的皮肤皮肤　　嘴对嘴，让快乐开始 / X4的　　所有我想要的就是吻　　因为你长得这麼好　　我要的就是你的嘴唇旁边的地雷　　就是这样。　　最好是比酒　　把你的手放在我的臀部。　　来吧 ... / X2的　　嘴唇同步...　　唇唇唇...这个这个这个这个 ...　　同步嘴唇嘴唇，嘴唇嘴唇...这个这个这个这个 ...　　同步的嘴唇。

看了jdk的帮助，有一段示例代码：Collection c = Collections.synchronizedCollection(myCollection);...synchronized(c) {Iterator i = c.iterator(); // Must be in the synchronized blockwhile (i.hasNext())foo(i.next());}Iterator并没有被同步包装

I"m wishing on a star And trying to believe That even though it"s far He"ll find me Christmas Eve (我希望在一颗星上，并试着相信即使它是遥不可及的，但他会在圣诞之夜看见我的存在)I guess that Santa"s busy Cause he"s never come around I think of him When Christmas Comes to Town (我猜想圣诞老人一定很忙，因为他从不回来每当圣诞降临城镇的时候，我就会想起他)The best time of the year When everyone comes home With all this Christmas cheer It"s hard to be alone (那是一年中最美好的时光，当人人都带着这份圣诞欢呼回家的时候，是不会感到孤独的)Putting up the Christmas treeWith friends who come aroundIt"s so much funWhen Christmas Comes to Town(当圣诞降临城镇的时候，和回来的朋友们一起抬起圣诞树，那是多么有趣)*Presents for the childrenWrapped in red and greenAll the things I"ve heard aboutBut never really seen(用红色和绿色包裹着的那些给孩子们的礼物，所有我听说过的事情，却从未真正看见过)No one will be sleeping onThe night of Christmas EveHoping Santa"s on his way*(无人能在圣诞夜入睡，因为人人都希望圣诞老人能来到他的身边)When Santa"s sleigh bells ringI listen all aroundThe herald angels singI never hear a sound(当圣诞老人的雪橇铃声响起，我到处都能听到传报天使在歌唱，那是我从未听到过的一种声音)When all the dreams of childrenOnce lost will all be foundThat"s all I want When Christmas Comes to Town(当圣诞降临城镇的时候，当所有的孩子们怀着梦想的时候，我所想要的，就是能找回曾经失去的)That"s all I wantWhen Christmas Comes to Town(当圣诞降临城镇的时候，那就是我所想要的)

没有volatile修饰的uniqueInstance[java] view plain copypublic class Singleton { private static Singleton uniqueInstance; private Singleton(){ } public static Singleton getInstance(){ if(uniqueInstance == null){ //#1 synchronized(Singleton.class){ //#2 if(uniqueInstance == null){ //#3 uniqueInstance = new Singleton(); //#4 System.out.println(Thread.currentThread().getName() + ": uniqueInstance is initalized..."); //#5.1 } else { System.out.println(Thread.currentThread().getName() + ": uniqueInstance is not null now..."); //#5.2 } } } return uniqueInstance; } } 这样可能会导致结果 Singleton被实例化两次 ，这样就不符合单例的特点原因分析：1. thread2进入#1， 这时子线程的uniqueInstance都是为空的，thread2让出CPU资源给thread32. thread3进入#1， 这时子线程的uniqueInstance都是为空的, thread3让出CPO资源给thread23. thread2会依次执行#2，#3，#4， #5.1，最终在thread2里面实例化了uniqueInstance。thread2执行完毕让出CPO资源给thread34. thread3接着#1跑下去，跑到#3的时候，由于#1里面拿到的uniqueInstance还是空（并没有及时从thread2里面拿到最新的），所以thread3仍然会执行#4，#5.15. 最后在thread2和thread3都实例化了uniqueInstance例子2：用volatile修饰的uniqueInstance这里就不贴重复的代码了，因为只是加多一个volatile来修饰成员变量：uniqueInstance，这样可以创建出一个单例实例。原因分析：volatile（java5）：可以保证多线程下的可见性;读volatile：每当子线程某一语句要用到volatile变量时，都会从主线程重新拷贝一份，这样就保证子线程的会跟主线程的一致。写volatile: 每当子线程某一语句要写volatile变量时，都会在读完后同步到主线程去，这样就保证主线程的变量及时更新。1. thread2进入#1， 这时子线程的uniqueInstance都是为空的（java内存模型会从主线程拷贝一份uniqueInstance=null到子线程thread2），thread2让出CPU资源给thread32. thread3进入#1， 这时子线程的uniqueInstance都是为空的（java内存模型会从主线程拷贝一份uniqueInstance=null到子线程thread2）, thread3让出CPO资源给thread23. thread2会依次执行#2，#3，#4， #5.1，最终在thread2里面实例化了uniqueInstance(由于是volatile修饰的变量，会马上同步到主线程的变量去)。thread2执行完毕让出CPO资源给thread34. thread3接着#1跑下去，跑到#3的时候，会又一次从主线程拷贝一份uniqueInstance！=null回来，所以thread3就直接跑到了#5.25. 最后在thread3不再会重复实例化uniqueInstance了

括号里的东西就是你要操作的内容呀，一个操作的逻辑，一串代码当然了，这个东西对所有试图访问它的人来说是共有的，同时只允许一个人去做举个很简单的例子，有一个打印机，同时好几个人想去用它synchronized{applyPrinter(); // 申请使用打印机}当然了，也可以把这个方法声明为synchronized的 synchronized void applyPrinter();也可以用Lock去做

synchronized在静态方法上表示调用前要获得类的锁，而在非静态方法上表示调用此方法前要获得对象的锁。public class StaticSynDemo {private static String a="test";//等同于方法print2public synchronized void print1(String b){ //调用前要取得StaticSynDemo实例化后对象的锁System.out.println(b+a);}public void print2(String b){synchronized (this) {//取得StaticSynDemo实例化后对象的锁System.out.println(b+a);}}//等同于方法print4public synchronized static void print3(String b){//调用前要取得StaticSynDemo.class类的锁System.out.println(b+a);}public static void print4(String b){synchronized (StaticSynDemo.class) { //取得StaticSynDemo.class类的锁System.out.println(b+a);}}}

你碰到这个问题属于多线程共享资源（余额）的问题，可以给使用资源加锁的做法，悲观锁和乐观锁都可以实现，悲观锁适用于并发压力小的情况，乐观锁适用于并发压力大的情况。具体概念可以百度查询。在changeBalance的方法上加synchronized声明是属于悲观锁的做法，实际操作一般使用数据库提供的锁，余额是保存在数据库中的，使用select for update来加悲观锁。乐观锁一般是在更新余额之前先查询余额相关的版本，然后在事物操作要提交之前再查一次版本，将两个版本比对，如果相同说明没有其它线程或进程更新过此资源，可以提交，提交过后版本更新，否则则回滚之前的操作，重新执行此事物操作。实际操作过程中，锁操作一般由数据库提供支持，分布式系统中现在最常用的的是zookeeper。

这个synchronized也可以放在方法头部声明的。synchronized线程并发机制吧

那是因为你插入的数据来源具有随机性。意思是说，你插入数据库中的nocode是从同一张表读取的，并做截取+1,有重复一点也不奇怪。

synchronized 是java保留的关键字，不在那个具体的类中。

传的是this 么？ 。。同一个.java 文件里应该没区别。。如果有多个class 。。 其中有个class是负责同步线程的，那么，这个参数就是需要被同步的对象吧 。。。这个是我的理解

建议看jdk的api，上面有官方说明的，是最全面的。

可以。Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。

synchronized是线程同步，和事务是两码事，我觉得不会影响

如果多个线程在同一时刻访问时就会出现意外。

首先synchronized不可能做到对某条数据库的数据加锁。它能做到的只是对象锁。比如数据表table_a中coloum_b的数据是临界数据，也就是你说的要保持一致的数据。你可以定义一个类，该类中定义两个方法read()和write()(注意，所有有关该临界资源的操作都定义在这个类中)，再定义一个静态变量作为锁就可以了。publicstaticfinalstringlock="table_a_b_lock";publicintread(){synchronizedlock{system.out.println("readdata...");}}publicvoidwrite(stringdata){synchronizedlock{system.out.println("writedata:"+data);}}另外，还可以在数据库级别加上锁。数据库本来就支持不同的隔离级别。

度君正解

首先要说明的是，java里不能直接使用synchronized声明一个变量，而是使用synchronized去修饰一个代码块或一个方法。详细说明如下： synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 五、以上规则对其它对象锁同样适用。示例代码：public class Thread1 implements Runnable { public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); } } } public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread ta = new Thread(t1, "A"); Thread tb = new Thread(t1, "B"); ta.start(); tb.start(); }}结果： A synchronized loop 0 A synchronized loop 1 A synchronized loop 2 A synchronized loop 3 A synchronized loop 4 B synchronized loop 0 B synchronized loop 1 B synchronized loop 2 B synchronized loop 3 B synchronized loop 4

你知道synchronized是起什么作用的吗？你知道run()在什么时候被调用吗？

首先要说明的是，java里不能直接使用synchronized声明一个变量，而是使用synchronized去修饰一个代码块或一个方法。x0dx0ax0dx0a详细说明如下：x0dx0ax0dx0a synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。x0dx0a 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。x0dx0a 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。x0dx0a 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。x0dx0a 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。x0dx0a 五、以上规则对其它对象锁同样适用。x0dx0ax0dx0a示例代码：x0dx0apublic class Thread1 implements Runnable { x0dx0a public void run() { x0dx0a synchronized(this) { x0dx0a for (int i = 0; i < 5; i++) { x0dx0a System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); x0dx0a } x0dx0a } x0dx0a } x0dx0a public static void main(String[] args) { x0dx0a Thread1 t1 = new Thread1(); x0dx0a Thread ta = new Thread(t1, "A"); x0dx0a Thread tb = new Thread(t1, "B"); x0dx0a ta.start(); x0dx0a tb.start(); x0dx0a }x0dx0a}x0dx0a结果： x0dx0a A synchronized loop 0 x0dx0a A synchronized loop 1 x0dx0a A synchronized loop 2 x0dx0a A synchronized loop 3 x0dx0a A synchronized loop 4 x0dx0a B synchronized loop 0 x0dx0a B synchronized loop 1 x0dx0a B synchronized loop 2 x0dx0a B synchronized loop 3 x0dx0a B synchronized loop 4

线程锁,即操作一个对象时，加入A正在操作，那么B只能等待A操作完后才能进行操作,在单例模式和多线程中用的蛮多.

最近写了个例子，比较了一下synchronized和ReentrantLock的性能，分享一下数据和个人观点。 本例中有位移运算和写文件操作。本人PC处理器是4核，java version "1.8.0_231"，例子中创建20个线程，每次测试循环500遍。 其实我也想测试更多的，但是一是慢，二是再多的数据会让Excel更卡。我做了N次测试，取了几次的数据，做成简易图表。 图中Y轴单位是纳秒，同时我删掉了部分数值特别大的，否则全挤到一块了。 synchronized有更好的稳定性和性能，更多点集中在底部，普遍低于500ns，数值高的点比Lock少很多。 ReentrantLock性能相对稳定且更好，但是synchronized的点有很多点集中在底部，而ReentrantLock分散的均匀。 取第一次位运算的底部放大 synchronized ReentrantLock 众所周知，synchronized由于偏向锁等优化性能有明显提高，所以现在单纯的说synchronized性能一定差就不一定准确了。 经过这几天我的反复测试，个人觉得synchronized在轻量化的操作，比如简单运算，变量递增/减，赋值等情况有更好的性能。ReentrantLock更适用于复杂度相对高的操作，比如循环遍历，插入，IO等。 在低并发，特别同时是轻量化的操作，synchronized可能可以获得更好的性能。现实情况中虽然我们可能有几百个线程，但是大多数情况下，对于共享资源的修改，同时只有几个或者十几个，那么使用synchronized也不失为一种好选择。 例子中文件操作受IO干扰比较大，不合理，改成遍历长度100的数组并赋值会怎么样？(经简单测试，lock更快) 在线程重入的情况下两者性能如何呢？(位运算，遍历数组并赋值synchronized更快，高近3个数量级) 组合synchronized和volatile对变量的增减操作和直接使用Atomicxxxx哪个更快（本人PC上是前者快，特别是并发很小的时候） 这里不得再次提一下以上结果都是基于本人PC的测试数据。因为还有10核一台云主机，测试中发现对于本例中文件操作结果是不确定的，对于synchronized+volatile的例子是低并发比如5个线程，那是前者快，否则是后这快。 测试中的数据还可以继续挖掘，比如在某一区间内的分布等。

synchronized(obj){代码块C}，其实锁的是obj这个对象。比如当多个线程要同时执行代码块C并且obj是同一个对象时，锁发挥作用（在任意时刻最多只有一个线程执行代码块C），注意：前提是obj是同一个对象。如果现在将代码改为synchronized(new Object()){代码块C}，这时将起不到锁的作用，因为每次锁得都是一个新的Object。

synchronized(obj)里的这个obj就是加锁的对象。

java语言的synchronized关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

java synchronized详解 记下来，很重要。 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 五、以上规则对其它对象锁同样适用. 举例说明： 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 packageths; var script = document.createElement("script"); script.src = "http://static.pay.baidu.com/resource/baichuan/ns.js"; document.body.appendChild(script); void function(e,t){for(var n=t.getElementsByTagName("img"),a=+new Date,i=[],o=function(){this.removeEventListener&&this.removeEventListener("load",o,!1),i.push({img:this,time:+new Date})},s=0;s< n.length;s++)!function(){var e=n[s];e.addEventListener?!e.complete&&e.addEventListener("load",o,!1):e.attachEvent&&e.attachEvent("onreadystatechange",function(){"complete"==e.readyState&&o.call(e,o)})}();alog("speed.set",{fsItems:i,fs:a})}(window,document);public class Thread1 implements Runnable { public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); } } } public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread ta = new Thread(t1, "A"); Thread tb = new Thread(t1, "B"); ta.start(); tb.start(); } } 结果： A synchronized loop 0 A synchronized loop 1 A synchronized loop 2 A synchronized loop 3 var cpro_psid ="u2572954"; var cpro_pswidth =966; var cpro_psheight =120;A synchronized loop 4 B synchronized loop 0 B synchronized loop 1 B synchronized loop 2 B synchronized loop 3 B synchronized loop 4 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 packageths; public class Thread2 { public void m4t1() { synchronized(this) { int i = 5; while( i-- > 0) { System.out.println(Thread.currentThread().getName() + " : " + i); try { Thread.sleep(500); } catch (InterruptedExceptionie) { } } }

在java编程思想中对synchronized的一点解释:1、synchronized关键字的作用域有二种：1）是某个对象实例内，synchronizedaMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；2）是某个类的范围，synchronizedstaticaStaticMethod{}防止多个线程同时访问这个类中的synchronizedstatic方法。它可以对类的所有对象实例起作用。

volatile和synchronized的区别：1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。3.volatile仅能实现变量的修改可见性，并能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。

把private int ticket=100;（基本数据类型）修改为private Integer ticket=100;就行了。（包装类）int是java中的基本数据类型，基本数据类型不允许使用synchronized，都会报 xxx is not a valid type"s argument for the synchronized statement，这个可能跟基础数据类型的存储类型有关，以下资料可以参考123456789101112131415161718192021222324252627282930311.java程序运行时有6种地方存储数据，分别是：寄存器、栈、堆、静态存储、常量存储、非RAM（随机存储器），主要是堆与栈的存储。2.堆与栈是java用来在RAM中存储数据的地方，java自动管理堆和栈，程序员不能直接设置堆和栈。3.栈的优势是：存取速度比堆要快，仅次于直接位于cpu中的寄存器；栈数据可以共享。 但缺点是：存在栈中数据大小与生命周期必须是确定的，缺乏灵活性。4.堆的优势在于可以动态分配内存大小，生存期也不必事先告诉编译器，java的垃圾收集器会自动收走这些不再使用的数据，缺点是由于要在运行时动态分配内存，存取速度较慢。5.基本数据类型的存储，java的基本数据类型共有8种：int,short,byte,long,float,double,boolean,(基本数据类型中并没有String的基本类型)。这种类型如int=3的形式来定义，称为自动变量。自动变量存在的是字面值，即不是类的实例，也不是类的引用。a 是一个指向int类型的引用，指向3这个字面值。这些字面值的数据由于大小可知，生存期可知（这些字面值固定定义在某个程序块里面，程序块退了，字段值就消失了），处于追求速度的原因就存在栈中。6.另外栈有一个很重要的特殊性，就是存在栈中的数据可以共享。如 需要定义int a = 3； int b =3；这两个自动变量。编译器先处理int a=3；首先在栈中创建一个变量为a的引用，然后查找栈有没有字面值为3的引用，没有找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b=3；在创建完b这个引用变量后，由于在栈中已经有了3这个字面值，即将b直接指向3的地址。这样，就出现了a和b同事指向3的情况。 定义完a与b后，在令a=4，那么b不会等于4，而是等于3,。在编译器内部，遇到时，它就会中新搜索栈中是否有4这个字面值，如果没有，重新开辟地址存放4的值。如果已经有就直接将a指向这个地址，因此a的值改变不会影响b的值。7.对象的内存模型.创建一个对象包括对象的声明和实例化两步：声明对象的引用和对象的实例化。声明一个对象引用时，将在栈内存为对象的引用变量分配空间；对象实例化是，在堆内存中为类成员变量分配内存，并将其初始化为各数据类型默认值，接着进行显示初始化，最后调用构造方法为成员变量赋值，返回堆内存中对象的引用（相当于首地址）给应用变量，通过引用变量来引用堆内存中的对象。8.包装类数据的存储：基本数据类型的定义都是直接在栈中，如果是包装类型来创建对象，就和普通对象一样。9.string数据类型是一种特殊数据类型，既可以用基本数据类型格式来创建，也可以用普通基本类型来创建。

mark!

Java的synchronized加在方法上或者对象上区别如下：1.synchronized在方法上，所有这个类的加了synchronized的方法，在执行时，会获得一个该类的唯一的同步锁，当这个锁被占用时，其他的加了synchronized的方法就必须等待

可以

synchronized，Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码块。你百度呀..

不存什么效率问题，都是线程同步用到，何来效率呢

Java的synchronized可以加在方法上，也可以直接加在对象上，从而保证一段代码只能有一个线程在运行，保证线程的同步。详情请见：http://blog.csdn.net/loveyaqin1990/article/details/41313285

没有唤醒吧。。

对象，对象的锁，必须时刻关注是锁的哪个对象。

volatile和synchronized的区别：1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。3.volatile仅能实现变量的修改可见性，并能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。 5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。

synchronized(this)是对象锁，如果有多个对象就有相对应的多个锁synchronized(类的名.class)是全局锁，不管有几个对象就公用一把锁求监督...

Thread.sleep操作线程能够将变量的修改同步到主存中。

synchronized 是可重入锁。当线程请求一个由其它线程持有的对象锁时，该线程会阻塞，而当线程请求由自己持有的对象锁时，如果该锁是重入锁，请求就会成功，否则阻塞。

会同步。。。。

synchronized有两种用法，一种是在方法定义时使用，多线程状态下，这个方法只能同时被同一个线程执行；另一种就是你问到的这种情况，用于锁定代码段，也就是说，{ }括号中的代码是不会同时被多个线程执行，而是排队执行。以上是回答Java的synchronized关键字，C#里有lock对应，用来所著一个对象，其他线程只有等到被锁住的对象lockObj被释放以后，才可以执行括号中的内容。

这个参数是指哪个对象是被互斥访问的。

synchronized是java中的一个关键字我们称其为同步关键字主要是用来处理java中的同步机制同一个资源被用户并发访问时，会出现并发问题，比如：有一个实例变量x，第一个用户访问它，并赋值为100，但还没有来得及打印出x，另一个哥们进来访问了x，并改为200，这时候第一个哥们兴高采烈的打印出x的值，但却发现不是100，是200.这哥们就郁闷了，怎么回事呢？这就是并发问题，但如果把上面的代码用同步代码块包含起来，任意一个时间只能有一个哥们访问实例变量x，一直到这哥们执行完同步代码块中的所有代码后，其他哥们才能再访问。

在java语言中，synchronized关键字通常用来修饰语句块或方法。被synchronized关键字修饰的语句块或方法在同一时间内只有一个线程 对象对它进行操作。

java中 synchronized同步处理后，代表该线程是同步的，即多线程访问时，无法同时有两个或以上线程进行访问。具体的原理是，当第一个线程进入该同步代码块之后，会暂时获得同步块的锁，当第二个线程进入时，由于第一个线程并未结束，同步代码块的锁没有释放，所以第二个线程进不来，达到只有一个线程在运行的目的。synchronized同步处理通常用于封装需要共享的可改变的数据，为了让数据更安全所使用的技术。

ReentrantLock 的lock机制有2种，忽略中断锁和响应中断锁，这给我们带来了很大的灵活性。比如：如果A、B2个线程去竞争锁，A线程得到了锁，B线程等待，但是A线程这个时候实在有太多事情要处理，就是 一直不返回，B线程可能就会等不及了，想中断自己，不再等待这个锁了，转而处理其他事情。这个时候ReentrantLock就提供了2种机制，第一，B线程中断自己（或者别的线程中断它），但是ReentrantLock 不去响应，继续让B线程等待，你再怎么中断，我全当耳边风（synchronized原语就是如此）；第二，B线程中断自己（或者别的线程中断它），ReentrantLock 处理了这个中断，并且不再等待这个锁的到来，完全放弃。请看例子：/** * @version 0.10 2009-11-6 * @author Zhang Hua */public class Test { //是用ReentrantLock，还是用synchronized public static boolean useSynchronized = false; public static void main(String[] args) { IBuffer buff = null; if(useSynchronized){ buff = new Buffer(); }else{ buff = new BufferInterruptibly(); } final Writer writer = new Writer(buff); final Reader reader = new Reader(buff); writer.start(); reader.start(); new Thread(new Runnable() { public void run() { long start = System.currentTimeMillis(); for (;;) { // 等5秒钟去中断读 if (System.currentTimeMillis() - start > 5000) { System.out.println("不等了，尝试中断"); reader.interrupt(); break; } } } }).start(); }}interface IBuffer{ public void write(); public void read() throws InterruptedException;}class Buffer implements IBuffer{ private Object lock; public Buffer() { lock = this; } public void write() { synchronized (lock) { long startTime = System.currentTimeMillis(); System.out.println("开始往这个buff写入数据…"); for (;;)// 模拟要处理很长时间 { if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE) break; } System.out.println("终于写完了"); } } public void read() { synchronized (lock) { System.out.println("从这个buff读数据"); } }}class BufferInterruptibly implements IBuffer{ private ReentrantLock lock = new ReentrantLock(); public void write() { lock.lock(); try { long startTime = System.currentTimeMillis(); System.out.println("开始往这个buff写入数据…"); for (;;)// 模拟要处理很长时间 { if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE) break; } System.out.println("终于写完了"); } finally { lock.unlock(); } } public void read() throws InterruptedException{ lock.lockInterruptibly();// 注意这里，可以响应中断 try { System.out.println("从这个buff读数据"); } finally { lock.unlock(); } }}class Writer extends Thread { private IBuffer buff; public Writer(IBuffer buff) { this.buff = buff; } @Override public void run() { buff.write(); }}class Reader extends Thread { private IBuffer buff; public Reader(IBuffer buff) { this.buff = buff; } @Override public void run() { try { buff.read(); } catch (InterruptedException e) { System.out.println("我不读了"); } System.out.println("读结束"); }}

synchronized的锁是针对多线程的，从线程的角度去思考才能真正弄明白。 Java的synchronized使用方法总结1． 把synchronized当作函数修饰符时这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。同步块，示例代码如下： public void method3(SomeObject so) { synchronized(so){ //…..}}这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁。3．将synchronized作用于static 函数，示例代码如下： Class Foo {public synchronized static void methodAAA() // 同步的static 函数{//….}public void methodBBB(){ synchronized(Foo.class) // class literal(类名称字面常量)} } 代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。

object是你指定加锁的对象

synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。

synchronized 的读法如下:synchronized 单词音标:英["su026au014bkru0259nau026azd] 美["su026au014bkru0259nau026azd]

synchronized 英["su026au014bkru0259nau026azd] 美["su026au014bkru0259nau026azd] [释义] 同步的; [网络] 线程,同步; 同步; 同时发生; [例句]The Modeler project that is being synchronized should not contain elements that are incomplete or not destined for implementation.正在进行同步的Modeler项目不应该包含不完整的或不是为实现预定的元素。

synchronized()、synchronized(this)、synchronized(类名.class)synchronized加在非静态方法前和synchronized(this)都是锁住了这个类的对象，如果多线程访问，对象不同，就锁不住，对象固定是一个，就可锁住。synchronized(类名.class)和加在静态方法前，是锁住了代码块，不管多线程访问的时候对象是不是同一个，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步，缩小锁的粒度。

区别如下：一、用在实例方法上时，同步的是当前对象(this)。二、用在静态方法上时，同步的是表示方法所属类的Class类的对象。比如，如果静态方法所属的类是C，则同步的就是C.class。三、用在代码块上时，同步的是某一个具体的引用类型的非null对象。比如，String lock="locker";synchronized(lock) {//需同步执行的代码}这里同步的就是字符串lock。

1、synchronized关键字的作用域有二种：1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

你这样写肯定同步不了。一个对象含有一个隐藏的锁和隐藏的条件，你这样synchronized(newObject()){}这种写法每次都会生成一个新对象，就等于每个线程都能获得这个新对象的锁，所以根本无法做到同步

锁机制，放在修饰符后面

有4种:instance 方法同步、instance 方法中部分程式码同步、static 方法同步、class literals 同步。

本质上都一样，但用lock对象可以更加直观，而且synchronized会有一些情况不能interrupt，比如等待IO操作的线程，但用lock就可以。

wait()会立刻释放synchronized（obj）中的obj锁，以便其他线程可以执行obj.notify()但是notify()不会立刻立刻释放sycronized（obj）中的obj锁，必须要等notify()所在线程执行完synchronized（obj）块中的所有代码才会释放这把锁.yield(),sleep()不会释放锁

synchronized修饰的函数是以所在类对象（Class对象）为锁的 而你synchronized语句用的count 所以自然两个互不相干-你貌似对锁的概念还不清楚|||锁只是是防止两个线程（不是叫进程，进程是操作系统的概念）同时访问一个数据。而不是直接不让其他线程改这个数据。只有两个线程同时获取一个锁的时候才能达到这个效果。说浅显点的话。比如线程A正大光明地说，我要使用count。这个时候线程B也正大光明地说，我要使用count。线程B就要等待线程A说我不用了，他才能用。这就是如果两个线程都在synchronized(count)中的情况。但是如果线程B偷偷摸摸地去用count，线程A什么办法也没有。这就是线程A在synchronized(count)中而线程B没在synchronized(count)中但也在写count的情况。你现在是两个线程一个在synchronized(Test)一个在synchronized(count)里一个说我要用Test类，一个说我要用count。自然用就用了。虽然前者其实也在用count，但是瞒天过海了。

一、synchronized和lock的用法区别synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。二、synchronized和lock用途区别synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。1.某个线程在等待一个锁的控制权的这段时间需要中断2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程3.具有公平锁功能，每个到来的线程都将排队等候

synchronized[英]["su026au014bkru0259nau026azd][美]["su026au014bkru0259nau026azd]同步的; 例句:1.What do you mean by incorrectly synchronized? 没有正确同步的含义是什么？2.Head first, united states team members practiced a technical routine at the olympicgames synchronized swimming qualifications in london. 美国国家队成员正倒立水中，为伦敦奥运的花样游泳资格赛进行技术自选训练。