多线程同步机制
同步机制应该遵循的规则
同步机制应该遵循的规则同步机制是指在多线程编程中，为了保证各个线程之间的有序执行和数据的一致性，需要遵循一定的规则。
本文将介绍同步机制应遵循的一些规则，包括互斥访问、临界区、互斥量、条件变量等。
一、互斥访问在多线程环境下，多个线程可能同时访问共享资源，为了避免数据竞争和不确定的结果，需要使用互斥访问机制。
互斥访问机制要求同一时间只能有一个线程访问共享资源，其他线程需要等待。
二、临界区临界区是指一段代码，同时只能有一个线程执行。
在进入临界区之前，需要先获取锁，执行完临界区代码后释放锁。
这样可以保证在临界区内的代码只能由一个线程执行，从而避免数据竞争和不一致的结果。
三、互斥量互斥量是一种同步机制，通过对共享资源加锁和解锁来实现线程的互斥访问。
在访问共享资源前，线程需要先获取互斥量的锁，如果锁被其他线程持有，则当前线程会被阻塞，直到锁被释放。
使用互斥量可以保证同一时间只有一个线程访问共享资源，从而确保数据的一致性。
四、条件变量条件变量是一种同步机制，用于线程之间的通信。
条件变量可以使线程在满足特定条件之前等待，一旦条件满足，线程将被唤醒继续执行。
条件变量通常与互斥量一起使用，以实现线程间的互斥和同步。
五、信号量信号量是一种同步机制，用于控制多个线程对共享资源的访问。
信号量有一个计数器，线程在访问资源前需要先等待信号量的计数器大于零，然后将计数器减一，表示占用一个资源。
当线程使用完资源后，需要释放信号量，使计数器加一，其他线程可以继续访问资源。
六、死锁避免在多线程编程中，死锁是一种常见的问题。
死锁指的是多个线程相互等待对方释放资源的情况，导致程序无法继续执行。
为了避免死锁，需要遵循以下原则：1.避免嵌套锁：在一个线程持有锁时，不再请求其他锁。
2.按相同的顺序获取锁：多个线程获取锁的顺序应该一致，避免出现循环等待的情况。
3.设置超时时间：在获取锁时设置超时时间，避免长时间等待导致死锁。
七、性能优化在使用同步机制时，还需要考虑性能优化的问题。
同步机制应遵循的规则
同步机制应遵循的规则同步机制是多线程编程中的重要概念，用于解决多线程之间共享资源的并发访问问题。
在使用同步机制时，需要遵循一些规则，以确保多线程能够正确地并发访问共享资源，保证程序的安全性和正确性。
以下是同步机制应遵循的一些规则：1. 互斥访问：同一时间只能有一个线程访问共享资源。
通过使用互斥锁（Mutex）或者信号量（Semaphore）等机制来实现。
使用互斥锁时，需要在访问共享资源之前加锁，在访问结束后释放锁。
2. 可见性保证：确保对共享资源的修改对其他线程是可见的。
这可以通过使用volatile关键字来实现。
volatile关键字可以确保对变量的读写操作在多线程之间保持可见性。
3. 原子操作：对于涉及多个线程操作的复合操作，应当将其作为一个整体进行处理，以确保在多线程环境下不会出现数据不一致的问题。
可以通过使用类似于原子变量（Atomic Variable）或者锁机制来实现。
4.等待和通知机制：在多线程环境中，有时需要线程等待一些条件满足后再继续执行，或者一些线程完成一些任务后通知其他线程继续执行。
这可以通过使用wait(、notify(和notifyAll(等方法来实现。
5.死锁避免：死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的情况。
为了避免死锁，应当遵循一定的调度顺序，避免出现循环依赖的资源竞争情况。
6.合理的资源管理：多线程环境下，需要合理地管理共享资源，以避免资源浪费和竞争。
一般来说，可以使用线程池来管理线程，将任务分配给空闲的线程来执行，避免频繁地创建和销毁线程。
7.优先级调度：可以使用优先级调度机制来控制多线程的执行顺序。
通过设置不同线程的优先级，可以控制线程对处理器资源的争夺程度。
8.临界区保护：临界区是指需要互斥访问的代码段。
对于临界区的访问，应该保证互斥性，避免多个线程同时进入临界区，导致数据不一致等问题的发生。
9.同步方法和同步块：可以使用同步方法和同步块来实现对共享资源的同步访问。
线程同步的3种方法
线程同步的3种方法
多线程编程的一个重要任务就是同步线程的操作，也就是让一个线程等待另一个线程结束才能继续执行。
对于同步线程的操作，有三种方法：信号量、互斥变量和读写锁。
信号量是一种重要的同步原语，它允许一个或多个线程访问受保护的资源。
它用来表示资源池中可用资源的数量，一个线程必须等待，直到有可用资源，然后才能使用资源。
它通常只能用于数据共享，这种数据共享是在不同线程之间进行的。
互斥变量是一种更高效的同步机制，通常被称为互斥锁或互斥量。
它可以使用一段代码包含在其中，该代码只能被一个线程同时执行，其他线程都必须等待它释放，然后才能继续运行。
它可以有效地解决多线程同时对一个变量的访问冲突，也可以用于互斥访问资源，在线程之间共享变量时也是有效的。
读写锁是一种特殊的互斥变量，它可以有效地实现多线程对受保护资源的访问，在多线程之间实现读写的互斥控制。
它的主要思想是分离读和写并发任务，使得读取资源的线程不会被写入资源的线程阻塞，而是可以同时进行。
总之，信号量、互斥变量和读写锁都是用于实现多线程同步操作的重要机制，它们各自有自己的优点和特点，可以根据实际情况更灵活地使用这三种机制来实现同步多线程操作，以实现更高效的程序性能。
- 1 -。
线程同步的方法有哪些
线程同步的方法有哪些线程同步是多线程编程中非常重要的一个概念，它是指多个线程在访问共享资源时，为了避免出现数据不一致或者冲突的情况，需要对线程进行协调和同步。
在实际的开发中，我们常常会遇到需要进行线程同步的情况，因此了解线程同步的方法是非常重要的。
本文将介绍几种常见的线程同步方法，希望能够帮助大家更好地理解和应用线程同步。
1. 互斥锁。
互斥锁是最常见的线程同步方法之一。
它通过对共享资源加锁的方式，保证同一时间只有一个线程可以访问该资源，其他线程需要等待锁的释放才能访问。
互斥锁可以使用操作系统提供的原子操作指令来实现，也可以使用编程语言提供的锁机制来实现，如Java中的synchronized关键字。
2. 信号量。
信号量是另一种常见的线程同步方法。
它可以用来控制对共享资源的访问权限，通过对信号量的值进行操作来实现线程的同步。
当信号量的值大于0时，表示资源可用，线程可以访问；当信号量的值等于0时，表示资源不可用，线程需要等待。
信号量的实现可以使用操作系统提供的信号量机制，也可以使用编程语言提供的信号量类来实现。
3. 条件变量。
条件变量是一种线程同步的高级方法，它可以用来在多个线程之间传递信息和控制线程的执行顺序。
条件变量通常和互斥锁一起使用，当共享资源的状态发生变化时，可以通过条件变量来通知等待的线程。
条件变量的实现通常需要依赖于操作系统提供的条件变量机制或者编程语言提供的条件变量类。
4. 读写锁。
读写锁是一种特殊的互斥锁，它可以提高对共享资源的并发访问性能。
读写锁允许多个线程同时对共享资源进行读操作，但是在进行写操作时需要互斥访问。
通过读写锁，可以有效地提高对共享资源的并发性能，适用于读操作频繁、写操作较少的场景。
5. 原子操作。
原子操作是一种特殊的指令序列，它可以保证在多线程环境下对共享资源的操作是原子性的，不会被中断。
原子操作通常由硬件提供支持，可以保证在执行过程中不会被其他线程打断，从而保证对共享资源的操作是线程安全的。
多线程同步的实现方法
多线程同步的实现方法在多线程编程中，为了保证数据的正确性和程序的稳定性，需要使用同步机制来控制不同线程之间对共享资源的访问。
本文将介绍几种常见的多线程同步实现方法。
一、互斥锁互斥锁是最基本也是最常用的一种同步机制。
它通过对共享资源加锁来防止其他线程同时访问该资源，从而避免数据竞争和冲突问题。
当一个线程获得了该锁后，其他想要访问该资源的线程就必须等待其释放锁才能进行操作。
在C++11标准中提供了std::mutex类作为互斥量，在使用时可以调用lock()函数获取锁并执行相应操作，再调用unlock()函数释放锁。
需要注意的是，在使用时应尽可能缩小临界区范围以提高效率，并确保所有涉及到共享资源修改或读取操作都被包含在临界区内。
二、条件变量条件变量通常与互斥锁结合起来使用，用于协调不同线程之间对某个事件或状态变化进行响应和处理。
当某个条件满足时（如队列非空），唤醒等待该条件变量上阻塞着的一个或多个进入等待状态（wait）的进程，使其重新参与竞争获取所需资源。
C++11标准库中提供了std::condition_variable类作为条件变量，在使用前需要先创建一个std::unique_lock对象并传递给wait()函数以自动解除已有lock对象，并将当前进入等待状态直至被唤醒；notify_one() 和 notify_all() 函数则分别用于唤醒单个或全部处于等待状态下面向此条件变量发出请求者。
三、信号量信号量是一种更复杂但功能更强大的同步机制。
它通过计数器记录可用资源数量，并根据计数器值判断是否允许新建任务运行或者挂起正在运行任务以便其他任务可以获得所需资源。
其中P(Proberen)表示申请/获取信号灯, V(Verhogen)表示释放/归还信号灯.C++11标准库没有直接支持Semaphore,但我们可以利用mutex+condition_variable模拟实现Semaphore. 其核心思想就是：定义两个成员属性count_ 和 mutex_, count_ 表示当前可申请 Semaphore 的数量 , mutex_ 是 std::mutex 类型 , 定义两个成员方法 wait(), signal(). 四、原子操作原子操作指不能被打断、干扰或交错执行影响结果正确性的操作。
多线程同步有几种实现方法
多线程同步有几种实现方法
多线程同步有几种实现方法，常见的有以下几种：
1. 互斥锁：通过互斥锁（Mutex）来控制多个线程对共享资源的访问。
同一时间只允许一个线程访问共享资源，其他线程需要等待锁的释放才能进行访问。
2. 条件变量：通过条件变量（Condition Variable）可以使一个线程等待特定的条件发生，当条件满足时，线程重新获得锁并继续执行。
常用的条件变量有信号量和事件。
3. 信号量：信号量（Semaphore）是一种通过计数器来实现线程间同步的机制。
当计数器大于0时，线程可以执行，当计数器等于0时，线程需要等待。
信号量可以用于限制同时访问某个资源的线程数量。
4. 事件：事件（Event）是一种通过线程等待和通知来实现同步的机制。
线程等待某个事件发生后才能继续执行，其他线程可以通过触发事件来通知等待的线程。
5. 自旋锁：自旋锁是一种忙等的方式，线程在获取锁时，如果发现锁被其他线程占用，就会一直循环尝试获取锁，直到成功获取。
6. 屏障：屏障（Barrier）是一种等待所有线程都达到某个状态后再继续执行的机制。
当所有线程都到达屏障点后，屏障才会打开，线程可以继续执行。
这些方法可以根据具体的场景和需求选择合适的方式来进行多线程同步。
多线程同步的几种方法
多线程同步的几种方法
多线程同步的几种方法主要包括临界区、互斥量、信号量、事件和读写锁等。
这些方法可以有效地控制多个线程对共享资源的访问，避免出现数据不一致和线程冲突的问题。
1．临界区：通过临界区实现多个线程对某一公共资源或一段代码的串行访问，可以保证某一时刻只有一个线程访问某一资源，速度快，适合控制数据的访问。
2．互斥量：互斥量是最简单的同步机制，即互斥锁。
多个进程（线程）均可以访问到一个互斥量，通过对互斥量加锁，从而来保护一个临界区，防止其它进程（线程）同时进入临界区，保护临界资源互斥访问。
3．信号量：信号量可以控制有限用户对同一资源的的访问而设计。
4．事件：通过通知线程的有一些事件已经发生，从而可以启动后续的任务执行。
5．读写锁：读写锁适合于使用在读操作多、写操作少的情况，比如数据库。
读写锁读锁可以同时加很多，但是写锁是互斥的。
当有进程或者线程要写时，必须等待所有的读进程或者线程都释放自己的读锁方可以写。
数据库很多时候可能只是做一些查询。
以上信息仅供参考，如有需要，建议咨询专业编程技术
人员。
多线程之线程同步的方法（7种）
多线程之线程同步的⽅法（7种）同步的⽅法：⼀、同步⽅法 即有synchronized关键字修饰的⽅法。
由于java的每个对象都有⼀个内置锁，当⽤此关键字修饰⽅法时，内置锁会保护整个⽅法。
在调⽤该⽅法前，需要获得内置锁，否则就处于阻塞状态。
注： synchronized关键字也可以修饰静态⽅法，此时如果调⽤该静态⽅法，将会锁住整个类。
⼆、同步代码块 即有synchronized关键字修饰的语句块。
被该关键字修饰的语句块会⾃动被加上内置锁，从⽽实现同步代码如：synchronized(object){}注：同步是⼀种⾼开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个⽅法，使⽤synchronized代码块同步关键代码即可。
package com.xhj.thread;/*** 线程同步的运⽤** @author XIEHEJUN**/public class SynchronizedThread {class Bank {private int account = 100;public int getAccount() {return account;}/*** ⽤同步⽅法实现** @param money*/public synchronized void save(int money) {account += money;}/*** ⽤同步代码块实现** @param money*/public void save1(int money) {synchronized (this) {account += money;}}}class NewThread implements Runnable {private Bank bank;public NewThread(Bank bank) {this.bank = bank;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {// bank.save1(10);bank.save(10);System.out.println(i + "账户余额为：" + bank.getAccount());}}}/*** 建⽴线程，调⽤内部类*/public void useThread() {Bank bank = new Bank();NewThread new_thread = new NewThread(bank);System.out.println("线程1");Thread thread1 = new Thread(new_thread);thread1.start();System.out.println("线程2");Thread thread2 = new Thread(new_thread);thread2.start();}public static void main(String[] args) {SynchronizedThread st = new SynchronizedThread();eThread();}}=====================================⽰例加讲解同步是多线程中的重要概念。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
内核对象也是系统用来存放进程统计信息的地方， 内核对象的数据结构只能被内核访问和使用，应用 程序在内存中无法找到该数据结构，并直接改变其 内容，只能通过Windows提供的一些API来对内核对 内容，只能通过Windows提供的一些API来对内核对 象进行操作
地址空间
包含所有可执行模块或DLL模块的代码和数据，也 包含所有可执行模块或DLL模块的代码和数据，也 包含动态内存分配的空间。
Java多线程协作（ Java多线程协作（续） 多线程协作
示例：
有一家汉堡店举办吃汉堡比赛，决赛时有3 有一家汉堡店举办吃汉堡比赛，决赛时有3个顾客来吃， 3个厨师来做，一个服务员负责协调汉堡的数量。为了 避免浪费，制作好的汉堡被放进一个能装有10个汉堡的 避免浪费，制作好的汉堡被放进一个能装有10个汉堡的 长条状容器中，按照先进先出的原则取汉堡。如果容 器被装满，则厨师停止做汉堡，如果顾客发现容器内 的汉堡吃完了，就可以拍响容器上的闹铃，提醒厨师 再做几个汉堡出来。此时服务员过来安抚顾客，让他 等待。而一旦厨师的汉堡做出来，就会让服务员通知 顾客，汉堡做好了，让顾客继续过来取汉堡。 顾客其实就是我们所说的消费者，而厨师就是生产者。 容器是决定厨师行为的监视器（在JVM中，此种监视器 容器是决定厨师行为的监视器（在JVM中，此种监视器 被称为等待并唤醒监视器。 ），而服务员则负责监视 顾客的行为。
多线程同步机制
--------- 李晓慧
目录
概念 为什么要同步 ？ Java中是如何实现多线程同步的？ Java中是如何实现多线程同步的？ VC中是如何实现多线程同步的？ VC中是如何实现多线程同步的？
概念
进程 线程 进程和线程的关系 多线程
ቤተ መጻሕፍቲ ባይዱ程
是应用程序的执行实例，每个进程是由私 有的虚拟地址空间、代码、数据和其它各 种系统资源组成 组成部分
为了解决synchronized 块存在的问题，JDK 5中新引入了 为了解决synchronized 块存在的问题，JDK 5中新引入了 并发框架中的锁机制。 java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作 为 Java 类，而不是作为语言的特性来实现 ReentrantLock是 ReentrantLock是“一个可重入的互斥锁 Lock，它具有 Lock，它具有 与使用 synchronized 方法和语句所访问的隐式监视器锁 相同的一些基本行为和语义，但功能更强大。
Java中锁的概念（ Java中锁的概念（续） 中锁的概念
类锁实际上用对象锁来实现。当虚拟机装载一个class文件 类锁实际上用对象锁来实现。当虚拟机装载一个class文件 的时候，它就会创建一个ng.Class类的实例。当锁住 的时候，它就会创建一个ng.Class类的实例。当锁住 一个对象的时候，实际上锁住的是那个类的Class对象。 一个对象的时候，实际上锁住的是那个类的Class对象。 一个线程可以多次对同一个对象上锁。对于每一个对象， java虚拟机维护一个加锁计数器，线程每获得一次该对象， java虚拟机维护一个加锁计数器，线程每获得一次该对象， 计数器就加1 计数器就加1，每释放一次，计数器就减 1，当计数器值为 0时，锁就被完全释放了。 java编程人员不需要自己动手加锁，对象锁是java虚拟机内 java编程人员不需要自己动手加锁，对象锁是java虚拟机内 部使用的。 在java程序中，只需要使用synchronized块或者synchronized java程序中，只需要使用synchronized块或者synchronized 方法就可以标志一个监视区域。当每次进入一个监视区域 时，java 时，java 虚拟机都会自动锁上对象或者类。
HambergShop
ThreadLocal
不论是同步还是重入锁，都不能实实在在的解决资源紧缺 的情况，这些方案只是靠制定规则来约束线程的行为，让 它们不再拼命的争抢，而不是真正从实质上解决他们对资 源的需求。 在JDK 1.2当中，引入了ng.ThreadLocal它为我们提供 1.2当中，引入了ng.ThreadLocal它为我们提供 了一种全新的思路来解决线程并发的问题，ThreadLocal其 了一种全新的思路来解决线程并发的问题，ThreadLocal其 实是源于一项多线程技术，叫做Thread 实是源于一项多线程技术，叫做Thread Local Storage，即 Storage，即 线程本地存储技术。 当使用ThreadLocal维护变量时，它会为每个使用该变量的 当使用ThreadLocal维护变量时，它会为每个使用该变量的 线程提供独立的变量副本，它是从根本上解决资源数量的 问题，从而使得每个线程持有相对独立的资源。这样，当 多个线程进行工作的时候，它们不需要纠结于同步的问题， 于是性能大大提升。但资源的扩张带来的是更多的空间消 耗，ThreadLocal就是一种利用空间来换取时间的解决方案。 耗，ThreadLocal就是一种利用空间来换取时间的解决方案。
线程
是进程内部的一个执行单元。系统创建好 进程后，实际上就启动执行了该进程的主 执行线程，主执行线程终止了，进程也就 随之终止。 组成部分
线程的内核对象
操作系统用它来对线程实施管理，也是系统用来存 放线程统计信息的地方
线程栈
用于维护线程在执行代码时需要的所有函数参数和 局部变量
进程和线程的关系
真正完成代码执行的是线程，而进程只是 线程的容器，或者说是线程的执行环境。 一个进程可以包含若干个线程，这些线程 都“同时”执行进程地址空间中的代码 同时” 一个进程至少拥有一个线程来执行其地址 空间中的代码，创建进程时系统会自动创 建这个进程的第一个线程，称为“ 建这个进程的第一个线程，称为“主线 程”。 线程总是在某个进程环境中创建，系统从 进程的地址空间中分配内存供线程的栈使 用。
Lock 锁（续）
Lock锁的优势： Lock锁的优势：
对象锁的获得和释放是由手工编码完成的，所以获得锁和释放锁 的时机比使用同步块具有更好的可定制性。并且通过程序的运行 结果（运行结果忽略，请读者根据例程自行观察），我们可以发 现，和使用同步块的版本相比，结果是相同的。 ReentrantLock 类（重入锁）实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候 和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况 下更佳的性能。（换句话说，当许多线程都想访问共享资源时， JVM 可以花更少的时候来调度线程，把更多时间用在执行线程 上。） 使用新的ReentrantLock，免去了为同步块放置合适的对象锁所要 使用新的ReentrantLock，免去了为同步块放置合适的对象锁所要 进行的考量 使用新的ReentrantLock，最佳的实践就是结合try/finally块来进行。 使用新的ReentrantLock，最佳的实践就是结合try/finally块来进行。 在try块之前使用lock方法，而在finally中使用unlock方法。 try块之前使用lock方法，而在finally中使用unlock方法。
对象锁
在Java多线程编程中，最常见的synchronized关键 Java多线程编程中，最常见的synchronized关键 字实际上是依靠对象锁的机制来实现线程同步的。 同步有两种方式，同步块和同步方法。 同步方法
则分静态和非静态两种 ，静态方法则一定会同步，非 静态方法需在同一个实例时才生效 对象锁即为method所在的对象，如果是静态方法，对 对象锁即为method所在的对象，如果是静态方法，对 象锁即指method所在的Class对象（唯一）； 象锁即指method所在的Class对象（唯一）；
synchronized块的限制： synchronized块的限制：
它无法中断一个正在等候获得锁的线程，也无法通过投票得到 锁，如果不想等下去，也就没法得到锁。 synchronized 块对于锁的获得和释放是在相同的堆栈帧中进行 的。多数情况下，这没问题（而且与异常处理交互得很好）， 但是，确实存在一些更适合使用非块结构锁定的情况。
为什么要同步？ 为什么要同步？
问题：
多个线程竞争同一个资源 资源紧缺 多线程协作
解决方法：
保证对共享资源的互斥访问 保证线程的先来后到 制定一个规则来约束线程的行为
Java中是如何实现多线程同步的？ Java中是如何实现多线程同步的？ 中是如何实现多线程同步的 Java中锁的概念 Java中锁的概念 对象锁 Lock锁 Lock锁 Java多线程协作 Java多线程协作 ThreadLocal
Java多线程协作（ Java多线程协作（续） 多线程协作
当线程在调用某个对象的wait或者notify方法的时 当线程在调用某个对象的wait或者notify方法的时 候，要先取得该对象的控制权，换句话说，就是 进入这个对象的监视器，因为：
任何一个时刻，对象的控制权只能被一个线程拥有。 无论是执行对象的wait、notify还是notifyAll方法，必须 无论是执行对象的wait、notify还是notifyAll方法，必须 保证当前运行的线程取得了该对象的控制权。 如果在没有控制权的线程里执行对象的以上三种方法， 就会报ng.IllegalMonitorStateException异常。 就会报ng.IllegalMonitorStateException异常。 JVM是基于多线程的，默认情况下不能保证运行时线程 JVM是基于多线程的，默认情况下不能保证运行时线程 的时序性。
Java中锁的概念 Java中锁的概念
多线程的线程同步机制实际上是靠锁的概念来控制的， 那么在Java程序当中，锁是如何体现的呢？ 那么在Java程序当中，锁是如何体现的呢？ 在Java程序运行时环境中，JVM需要对两类线程共享的 Java程序运行时环境中，JVM需要对两类线程共享的 数据进行协调：1 数据进行协调：1）保存在堆中的实例变量 ；2）保存在 方法区中的类变量 。这两类数据是被所有线程共享的。 在java虚拟机中，每个对象和类在逻辑上都是和一个监 java虚拟机中，每个对象和类在逻辑上都是和一个监 视器相关联的；对于对象来说，相关联的监视器保护对 象的实例变量；对于类来说，监视器保护类的类变量。 为了实现监视器的排他性监视能力，java虚拟机为每一 为了实现监视器的排他性监视能力，java虚拟机为每一 个对象和类都关联一个锁。代表任何时候只允许一个线 程拥有的特权。线程访问实例变量或者类变量不需锁， 但是如果线程获取了锁，那么在它释放这个锁之前，就 没有其他线程可以获取同样数据的锁了，锁住一个对象 就是获取对象相关联的监视器。