java方法synchronized在哪个类里面

synchronized英["su026au014bkru0259nau026azd]美["su026au014bkru0259nau026azd]词典同步的网络同步; 关键字; 同步锁形近词：synchronisersynchronizersynchroniaed数据来源：金山词霸双语例句柯林斯词典英英释义百度百科百度知道新1The Modeler project that is being synchronized should not contain elements that are incomplete or not destined for implementation.正在进行同步的Modeler项目不应该包含不完整的或不是为实现预定的元素。

iciba 很方便查询，还有语音发声

synchronized是synchronize的过去分词synchronize美 ["su026au014bkru0259.nau026az] 英 ["su026au014bkru0259nau026az]v.同时化；【物】同步；【影视】声；使同时网络同步的；同步化；同步方法第三人称单数：synchronizes 现在分词：synchronizing 过去分词：synchronized 例句筛选1.It has no SIM card and allows contacts to be saved andsynchronized on the Internet.它没有SIM卡，允许在互联网上保存和同步联系人。2.Deactivates subscriptions that have not been synchronizedwithin the maximum distribution retention period.停用在最大分发保持期内尚未同步的订阅。

1、synchronized英[u02c8su026au014bkru0259nau026azd]美[u02c8su026au014bkru0259nau026azd]，v.(使)同步，在时间上一致，同速进行;synchronize的过去分词和过去式。 2、[例句]which is synchronized with the heart rate monitor around your chest.与你胸口的心率监测器同步。

synchronized 底层如何实现？什么是锁的升级，降级。 操作系统分为用户态和内核态，应用级别的程序会运行在用户态，不能访问硬件，操作系统内核的程序会运行在内核态，可以直接访问硬件。synchronized 是重量级锁，运行在虚拟机上，而虚拟机是应用级别的程序，运行在用户态，需要通过向操作系统内核程序发出申请，得到反馈获得锁，所以称sychronized为重量级锁。而cas的锁直接运行在用户态，所以称为轻量级锁。 CAS 叫自旋锁或者无锁，是轻量级锁，用于替代synchronized。 CAS的ABA问题可以用版本号解决。可是如果一个线程在比较值相同的情况下，在修改值之前另一个线程有可能提前修改当前值，这怎么避免呢？如下图： 在用c++编写的native方法compareAndSwap中，如果多线程的情况下，会有 lock cmpxchg这条指令来保证线程安全。在底层有多个cpu指向同一条语句（CAS）时，多个cpu通过一条总线通向这条语句，当lock时，会掐断这条总线，直到通向这条语句的cpu执行完成，总线又连上，允许其他cpu操作这条语句。 Markword的前四个字节中记录了synchronized的锁信息。 轻量级锁也称为自旋锁。除了重量级锁，其他锁都是在用户态完成。 锁升级指的是轻量级锁升级成重量级锁。 为什么自旋锁可以完成多线程的安全，为什么在竞争激烈的情况下要升级成重量级锁，因为自旋锁这些线程一直在while循环，消耗cpu的资源，而重量级锁这些线程排成队列，不消耗cpu资源，这里又可以分为公平锁和非公平锁。 偏向锁是默认启动的，但是有4s的延迟。 启动偏向锁为什么要延迟4秒：因为启动偏向锁效率不一定会提升。如果一开始就知道会有很多线程竞争锁，那么就不必打开偏向锁，从而提高效率。 Synchronized的底层实现： Synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。Synchronized的作用主要有三个： 从语法上讲，Synchronized可以把任何一个非null对象作为"锁"，在HotSpot JVM实现中， 锁有个专门的名字：对象监视器（Object Monitor） 。 Synchronized总共有三种用法： 注意，synchronized 内置锁 是一种对象锁（锁的是对象而非引用变量）， 作用粒度是对象 ，可以用来实现对临界资源的同步互斥访问，是 可重入 的。其可重入最大的作用是避免死锁 ，如： 子类同步方法调用了父类同步方法，如没有可重入的特性，则会发生死锁； monitorenter ：每个对象都是一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下： (1). 如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者； (2). 如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1； (3). 如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权； monitorexit：执行monitorexit的线程必须是objectref所对应的monitor的所有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。 monitorexit指令出现了两次，第1次为同步正常退出释放锁；第2次为发生异步退出释放锁； 通过上面两段描述，我们应该能很清楚的看出Synchronized的实现原理， Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

在虚拟机执行到monitorenter指令的时候，会请求获取对象的monitor锁，基于monitor锁又衍生出一个锁计数器的概念。当执行monitorenter时，若对象未被锁定时，或者当前线程已经拥有了此对象的monitor锁，则锁计数器+1，该线程获取该对象锁。当执行monitorexit时，锁计数器-1，当计数器为0时，此对象锁就被释放了。那么其他阻塞的线程则可以请求获取该monitor锁。扩展资料synchronized的特性1、原子性所谓原子性就是指一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。2、可见性可见性是指多个线程访问一个资源时，该资源的状态、值信息等对于其他线程都是可见的。3、有序性有序性值程序执行的顺序按照代码先后执行。4、可重入性synchronized和ReentrantLock都是可重入锁。当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁。

就是对系统内部进行修改，对代码进行修改，对安防系统进行修改，这样就完成了锁优化。

　　由于同一进程内的多个线程共享内存空间 在Java中 就是共享实例 当多个线程试图同时修改某个实例的内容时 就会造成冲突 因此 线程必须实现共享互斥 使多线程同步 　　最简单的同步是将一个方法标记为synchronized 对同一个实例来说 任一时刻只能有一个synchronized方法在执行 当一个方法正在执行某个synchronized方法时 其他线程如果想要执行这个实例的任意一个synchronized方法 都必须等待当前执行 synchronized方法的线程退出此方法后 才能依次执行 　　但是 非synchronized方法不受影响 不管当前有没有执行synchronized方法 非synchronized方法都可以被多个线程同时执行 　　此外 必须注意 只有同一实例的synchronized方法同一时间只能被一个线程执行 不同实例的synchronized方法是可以并发的 例如 class A定义了synchronized方法sync（） 则不同实例a sync（）和a sync（）可以同时由两个线程来执行 　　多线程同步的实现最终依赖锁机制 我们可以想象某一共享资源是一间屋子 每个人都是一个线程 当A希望进入房间时 他必须获得门锁 一旦A获得门锁 他进去后就立刻将门锁上 于是B C D就不得不在门外等待 直到A释放锁出来后 B C D中的某一人抢到了该锁（具体抢法依赖于 JVM的实现 可以先到先得 也可以随机挑选） 然后进屋又将门锁上 这样 任一时刻最多有一人在屋内（使用共享资源） 　　Java语言规范内置了对多线程的支持 对于Java程序来说 每一个对象实例都有一把 锁 一旦某个线程获得了该锁 别的线程如果希望获得该锁 只能等待这个线程释放锁之后 获得锁的方法只有一个 就是synchronized关键字 例如 　　public class SharedResource { 　　private int count = ; 　　public int getCount（） { return count; } 　　public synchronized void setCount（int count） { unt = count; } 　　} 　　同步方法public synchronized void setCount（int count） { unt = count; } 事实上相当于 　　public void setCount（int count） { 　　synchronized（this） { // 在此获得this锁 　　unt = count; 　　} // 在此释放this锁 　　} 　　红色部分表示需要同步的代码段 该区域为 危险区域 如果两个以上的线程同时执行 会引发冲突 因此 要更改SharedResource的内部状态 必须先获得SharedResource实例的锁 　　退出synchronized块时 线程拥有的锁自动释放 于是 别的线程又可以获取该锁了 　　为了提高性能 不一定要锁定this 例如 SharedResource有两个独立变化的变量 　　public class SharedResouce { 　　private int a = ; 　　private int b = ; 　　public synchronized void setA（int a） { this a = a; } 　　public synchronized void setB（int b） { this b = b; } 　　} 　　若同步整个方法 则setA（）的时候无法setB（） setB（）时无法setA（） 为了提高性能 可以使用不同对象的锁 　　public class SharedResouce { 　　private int a = ; 　　private int b = ; 　　private Object sync_a = new Object（） 　　private Object sync_b = new Object（） 　　public void setA（int a） { 　　synchronized（sync_a） { 　　this a = a; 　　} 　　} 　　public synchronized void setB（int b） { 　　synchronized（sync_b） { 　　this b = b; 　　} lishixinzhi/Article/program/Java/gj/201311/27512

synchronized 的作用范围：synchronized加在方法前等价于synchronized(this);this是实例本身，因此作用范围就是当前类，这等价于使用非静态的全局变量。除非是在静态方法上加，否则作用范围是对象this，而不是class。举例：public synchronized static void execute(){ //...}等同于public class TestThread {public static void execute(){ synchronized(TestThread.class){ // } }7}

1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情ReentrantLock获取锁定与三种方式：a) lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；c)tryLock(long timeout,TimeUnit unit)， 如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；5.0的多线程任务包对于同步的性能方面有了很大的改进，在原有synchronized关键字的基础上，又增加了ReentrantLock，以及各种Atomic类。了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择。

两者区别：1.synchronized是java内置关键字，在jvm层面，Lock是java类；2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。7.Lock是一个接口，synchronized是一个关键字，synchronized放弃锁只有两种情况：①线程执行完了同步代码块的内容②发生异常；而lock不同，它可以设定超时时间，也就是说他可以在获取锁时便设定超时时间，如果在你设定的时间内它还没有获取到锁，那么它会放弃获取锁然后响应放弃操作。你明白了吗？

在多线程的情况下，由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：public synchronized void accessVal(int newVal);synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：synchronized(syncObject) {//允许访问控制的代码}synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。 通常问这个问题应该都是涉及到多线程了，如果是在自己学java多线程编程的话，建议搭好环境多敲代码试试，会发现很多有意思的事情，无论是自己看书还是百度知道能帮到你的很少。

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

代表这个方法加索,相当于每一次运行到这个法,都要检查有没有其它正在用这个方法的程序,有的话要等其它运行完这个方法后再运行此线程,没有的话,直接运行

synchronized的参数代表的是“对象锁”。sychronized加锁的是对象，而不是代码。举了例子：public class Person{private String name; //意思差不多就是你那个objpublic setName(String name){synchronized(name){this.name = name;}}}代表的是不同的线程在synchronized块里，同时只有一个线程能执行该代码块,而类的不同实例之间是互不影响的。比如Person A = new Person(),Person B = new Person().A和B之间是不受synchronized制约的。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。

lock和synchronized区别：1. Lock是一个接口，而synchronized是Java中的关键字，Lock需要通过lock()和unlock()方法显式实现加锁和释放锁，而synchronized不需要。2. Lock可以提高多个线程进行读写操作的效率。synchronized却不行，因为他只能进行一个线程的读写操作。3. Lock可以实现公平锁，synchronized却不行。4. Lock可以替代synchronized实现线程同步，而且Lock提供比synchronized更多的功能。拓展：Lock还提供了一种机制，可以知道线程的中断状态，在一些场景中可以使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行，在一些特殊场合下可以使用。同时，ReentrantLock还可以指定为公平锁，使多个线程按照申请锁的顺序来访问共享资源，这样也能够提高多线程的并发能力。

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产生的某个具体对象了）。

参考我以前的回答：Java的synchronized加在方法上或者对象上区别如下：1.synchronized 在方法上，所有这个类的加了 synchronized 的方法，在执行时，会获得一个该类的唯一的同步锁，当这个锁被占用时，其他的加了 synchronized 的方法就必须等待2.加在对象上的话，就是以这个对象为锁，其他也以这个对象为锁的代码段，在这个锁被占用时，就必须等待

这个方法，只允许一个线程进入。

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

在分布式开发中，锁是线程控制的重要途径。Java为此也提供了2种锁机制，synchronized和lock。做为Java爱好者，自然少不了对比一下这2种机制，也能从中学到些分布式开发需要注意的地方。我们先从最简单的入手，逐步分析这2种的区别。一、synchronized和lock的用法区别synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。用法区别比较简单，这里不赘述了，如果不懂的可以看看Java基本语法。二、synchronized和lock性能区别synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。在Java1.5中，synchronize是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象，性能更高一些。但是到了Java1.6，发生了变化。synchronize在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在Java1.6上synchronize的性能并不比Lock差。官方也表示，他们也更支持synchronize，在未来的版本中还有优化余地。说到这里，还是想提一下这2中机制的具体区别。据我所知，synchronized原始采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。而在CPU转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起CPU频繁的上下文切换导致效率很低。而Lock用的是乐观锁方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是CAS操作（Compare and Swap）。我们可以进一步研究ReentrantLock的源代码，会发现其中比较重要的获得锁的一个方法是compareAndSetState。这里其实就是调用的CPU提供的特殊指令。现代的CPU提供了指令，可以自动更新共享数据，而且能够检测到其他线程的干扰，而 compareAndSet() 就用这些代替了锁定。这个算法称作非阻塞算法，意思是一个线程的失败或者挂起不应该影响其他线程的失败或挂起的算法。我也只是了解到这一步，具体到CPU的算法如果感兴趣的读者还可以在查阅下，如果有更好的解释也可以给我留言，我也学习下。三、synchronized和lock用途区别synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。1.某个线程在等待一个锁的控制权的这段时间需要中断2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程3.具有公平锁功能，每个到来的线程都将排队等候下面细细道来……先说第一种情况，ReentrantLock的lock机制有2种，忽略中断锁和响应中断锁，这给我们带来了很大的灵活性。比如：如果A、B2个线程去竞争锁，A线程得到了锁，B线程等待，但是A线程这个时候实在有太多事情要处理，就是一直不返回，B线程可能就会等不及了，想中断自己，不再等待这个锁了，转而处理其他事情。这个时候ReentrantLock就提供了2种机制，第一，B线程中断自己（或者别的线程中断它），但是ReentrantLock不去响应，继续让B线程等待，你再怎么中断，我全当耳边风（synchronized原语就是如此）；第二，B线程中断自己（或者别的线程中断它），ReentrantLock处理了这个中断，并且不再等待这个锁的到来，完全放弃。（如果你没有了解java的中断机制，请参考下相关资料，再回头看这篇文章，80%的人根本没有真正理解什么是java的中断，呵呵）这里来做个试验，首先搞一个Buffer类，它有读操作和写操作，为了不读到脏数据，写和读都需要加锁，我们先用synchronized原语来加锁，如下：1 public class Buffer { 2 3 private Object lock; 4 5 public Buffer() { 6 lock = this; 7 } 8 9 public void write() { 10 synchronized (lock) { 11 long startTime = System.currentTimeMillis(); 12 System.out.println("开始往这个buff写入数据…"); 13 for (;;)// 模拟要处理很长时间 14 { 15 if (System.currentTimeMillis() 16 - startTime > Integer.MAX_VALUE) 17 break; 18 } 19 System.out.println("终于写完了"); 20 } 21 } 22 23 public void read() { 24 synchronized (lock) { 25 System.out.println("从这个buff读数据"); 26 } 27 } 28

在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。关于非公平锁非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

不是，可以不用synchronized，但Java推荐在调用wait方法前将对象锁住其实，从并发的角度考虑，wait是不能放在synchronized锁里的，会引起死锁。试考虑，当wait和notify方法都在synchronized锁里的时候，调用wait方法前将对象锁住，然后调用wait方法，线程被挂起，需要其它线程调用notify将其唤醒。由于notify方法也在synchronized里面，其它线程调用notify的时候要获得对象的锁，但此时锁已经被wait所在的线程持有，而且wait线程已经被挂起，所以notify因为无法获得锁而挂起，这样二者相互等待，导致死锁。Java里面可以将wait和notify放在synchronized里面，是因为Java是这样处理的：在synchronized代码被执行期间，线程调用对象的wait()方法，会释放对象锁标志，然后进入等待状态，然后由其它线程调用notify()或者notifyAll()方法通知正在等待的线程。

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. 美国国家队成员正倒立水中，为伦敦奥运的花样游泳资格赛进行技术自选训练。

一、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修饰的函数是以所在类对象（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，但是瞒天过海了。

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

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

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

锁机制，放在修饰符后面

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

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

一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功获得锁，并且还没有释放该锁的线程所拥有。当锁没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁并返回。如果当前线程已经拥有该锁，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。

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

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

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 单词音标:英["su026au014bkru0259nau026azd] 美["su026au014bkru0259nau026azd]

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

object是你指定加锁的对象

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产生的某个具体对象了）。

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("读结束"); }}

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

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

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

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

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

会同步。。。。

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

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