使用Synchronized关键字同步类方法
要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步，代码如下：1public synchronized void run()2{34}从上面的代码可以看出，只要在void和public之间加上synchronized关键字，就可以使run方法同步，也就是说，对于同一个Java类的对象实例，run方法同时只能被一个线程调用，并当前的run执行完后，才能被其他的线程调用。
即使当前线程执行到了run方法中的yield方法，也只是暂停了一下。
由于其他线程无法执行run方法，因此，最终还是会由当前的线程来继续执行。
先看看下面的代码：sychronized关键字只和一个对象实例绑定5class Test6{7public synchronized void method()8{910}11}1213public class Sync implements Runnable14{15private Test test;16public void run()17{18test.method();19}20public Sync(Test test)21{22this.test = test;23}24public static void main(String[] args) throws Exception25{26Test test1 = new Test();27Test test2 = new Test();28Sync sync1 = new Sync(test1);29Sync sync2 = new Sync(test2);30new Thread(sync1).start();31new Thread(sync2).start();32}33}在Test类中的method方法是同步的。
但上面的代码建立了两个Test类的实例，因此，test1和test2的method方法是分别执行的。
要想让method同步，必须在建立Sync类的实例时向它的构造方法中传入同一个Test类的实例，如下面的代码所示：Sync sync1 = new Sync(test1); 不仅可以使用synchronized来同步非静态方法，也可以使用synchronized来同步静态方法。
如可以按如下方式来定义method方法：34class Test35{36public static synchronized void method() { }37}建立Test类的对象实例如下：38Test test = new Test();对于静态方法来说，只要加上了synchronized关键字，这个方法就是同步的，无论是使用test.method()，还是使用Test.method()来调用method方法，method都是同步的，并不存在非静态方法的多个实例的问题。
在23种设计模式中的单件（Singleton）模式如果按传统的方法设计，也是线程不安全的，下面的代码是一个线程不安全的单件模式。
39package test;4041// 线程安全的Singleton模式42class Singleton43{44private static Singleton sample;4546private Singleton()47{48}49public static Singleton getInstance()50{51if (sample == null)52{53Thread.yield(); // 为了放大Singleton模式的线程不安全性54sample = new Singleton();55}56return sample;57}58}59public class MyThread extends Thread60{61public void run()62{63Singleton singleton = Singleton.getInstance();64System.out.println(singleton.hashCode());65}66public static void main(String[] args)67{68Thread threads[] = new Thread[5];69for (int i = 0; i < threads.length; i++)70threads[i] = new MyThread();71for (int i = 0; i < threads.length; i++)72threads[i].start();73}74}在上面的代码调用yield方法是为了使单件模式的线程不安全性表现出来，如果将这行去掉，上面的实现仍然是线程不安全的，只是出现的可能性小得多。
程序的运行结果如下：25358555263995547051261298553195383406上面的运行结果可能在不同的运行环境上有所有同，但一般这五行输出不会完全相同。
从这个输出结果可以看出，通过getInstance方法得到的对象实例是五个，而不是我们期望的一个。
这是因为当一个线程执行了Thread.yield()后，就将CPU资源交给了另外一个线程。
由于在线程之间切换时并未执行到创建Singleton对象实例的语句，因此，这几个线程都通过了if判断，所以，就会产生了建立五个对象实例的情况（可能创建的是四个或三个对象实例，这取决于有多少个线程在创建Singleton对象之前通过了if判断，每次运行时可能结果会不一样）。
要想使上面的单件模式变成线程安全的，只要为getInstance加上synchronized关键字即可。
代码如下：75public static synchronized Singleton getInstance() { }当然，还有更简单的方法，就是在定义Singleton变量时就建立Singleton对象，代码如下：76private static final Singleton sample = new Singleton();然后在getInstance方法中直接将sample返回即可。
这种方式虽然简单，但不如在getInstance 方法中创建Singleton对象灵活。
读者可以根据具体的需求选择使用不同的方法来实现单件模式。
在使用synchronized关键字时有以下四点需要注意：1. synchronized关键字不能继承。
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。
如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。
当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。
这两种方式的例子代码如下：在子类方法中加上synchronized关键字77class Parent78{79public synchronized void method() { }80}81class Child extends Parent82{83public synchronized void method() { }84}在子类方法中调用父类的同步方法85class Parent86{87public synchronized void method() { }88}89class Child extends Parent90{91public void method() { super.method(); }92}2. 在定义接口方法时不能使用synchronized关键字。
3. 构造方法不能使用synchronized关键字，但可以使用下节要讨论的synchronized块来进行同步。
4. synchronized可以自由放置。
在前面的例子中使用都是将synchronized关键字放在方法的返回类型前面。
但这并不是synchronized可放置唯一位置。
在非静态方法中，synchronized还可以放在方法定义的最前面，在静态方法中，synchronized可以放在static的前面，代码如下：93public synchronized void method();94synchronized public void method();95public static synchronized void method();96public synchronized static void method();97synchronized public static void method();但要注意，synchronized不能放在方法返回类型的后面，如下面的代码是错误的：98public void synchronized method();99public static void synchronized method();synchronized关键字只能用来同步方法，不能用来同步类变量，如下面的代码也是错误的。
100public synchronized int n = 0;101public static synchronized int n = 0;虽然使用synchronized关键字同步方法是最安全的同步方式，但大量使用synchronized 关键字会造成不必要的资源消耗以及性能损失。
虽然从表面上看synchronized锁定的是一个方法，但实际上synchronized锁定的是一个类。
也就是说，如果在非静态方法method1和method2定义时都使用了synchronized，在method1未执行完之前，method2是不能执行的。
静态方法和非静态方法的情况类似。
但静态和非静态方法不会互相影响。
看看如下的代码：102package test;103104public class MyThread1 extends Thread105{106public String methodName;107108public static void method(String s)109{110System.out.println(s);111while (true)112;113}114public synchronized void method1()115{116method("非静态的method1方法");117}118public synchronized void method2()119{120method("非静态的method2方法");121}122public static synchronized void method3()123{124method("静态的method3方法");125}126public static synchronized void method4()127{128method("静态的method4方法");129}130public void run()131{132try133{134getClass().getMethod(methodName).invoke(this);135}136catch (Exception e)137{138}139}140public static void main(String[] args) throws Exception141{142MyThread1 myThread1 = new MyThread1();143for (int i = 1; i <= 4; i++)144{145myThread1.methodName = "method" + String.valueOf(i);146new Thread(myThread1).start();147sleep(100);148}149}150}运行结果如下：非静态的method1方法静态的method3方法从上面的运行结果可以看出，method2和method4在method1和method3未结束之前不能运行。
多线程之线程同步的方法（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();}}=====================================⽰例加讲解同步是多线程中的重要概念。
java synchronized同步方法
一、介绍Java synchronized同步方法在Java编程语言中，synchronized关键字被广泛用于实现线程同步。
在多线程编程中，同步方法可以确保多个线程对共享资源的访问是安全的，从而避免出现竞态条件和其他潜在的并发问题。
本文将介绍Java中的synchronized同步方法的相关概念、用法和注意事项。
二、synchronized关键字的基本概念1. synchronized关键字的作用synchronized关键字可以用于修饰方法，也可以用于修饰代码块。
当修饰方法时，它可以确保在同一时间内只有一个线程能够访问该方法。
当修饰代码块时，它可以确保在同一时间内只有一个线程能够访问被修饰的代码块。
2. synchronized关键字的使用场景synchronized关键字通常用于解决多线程并发访问共享资源时可能出现的竞态条件和数据不一致的问题。
在需要确保线程安全的情况下，我们可以使用synchronized来对关键代码进行同步。
三、synchronized同步方法的使用方法1. 修饰实例方法当我们需要对一个实例方法进行同步时，可以在方法的声明中使用synchronized关键字，如下所示：```javapublic synchronized void doSomething() {// 方法的具体实现}```2. 修饰静态方法当我们需要对一个静态方法进行同步时，可以在方法的声明中使用synchronized关键字，并在关键字前加上static，如下所示：```javapublic static synchronized void doSomethingStatic() {// 方法的具体实现}```3. 同步方法的原理当一个线程调用一个同步方法时，它将尝试获得该对象的锁。
如果锁已被其他线程占用，那么该线程会被阻塞，直到锁被释放。
一旦获得锁，线程就可以执行方法体中的代码，执行完毕后释放锁。
四、synchronized同步方法的注意事项1. 锁的粒度在使用synchronized同步方法时，需要注意锁的粒度。
线程练习题——精选推荐
线程练习题答：有两种实现方法，分别是继承Thread类与实现Runnable接口用synchronized关键字修饰同步方法反对使用stop，是因为它不安全。
它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。
结果很难检查出真正的问题所在。
suspend方法容易发生死锁。
调用suspend 的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。
此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。
对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。
所以不应该使用suspend，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。
若标志指出线程应该挂起，便用wait命其进入等待状态。
若标志指出线程应当恢复，则用一个notify重新启动线程。
2、sleep 和 wait 有什么区别?答：sleep是线程类的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。
调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法后本线程才进入对象锁定池准备获得对象锁进入运行状态。
3、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
答：如果数据将在线程间共享。
例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
4、启动一个线程是用run还是start?答：启动一个线程是调用start方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。
android线程间同步 原理
android线程间同步原理Android线程间同步是指通过一定的机制来保证多个线程之间的操作按照一定的顺序进行，避免出现数据竞争和并发问题。
在Android开发中，线程间同步是非常重要的一部分，它能够保证程序的正确性和稳定性。
Android中的线程间同步主要通过以下几种方式实现：1. 使用synchronized关键字：synchronized关键字可以修饰方法或代码块，当一个线程访问被synchronized修饰的代码时，其他线程必须等待该线程执行完毕才能继续执行。
这样可以保证多个线程对共享资源的互斥访问。
2. 使用Lock锁：Lock是Java.util.concurrent包下的一个接口，它提供了比synchronized更加灵活和可扩展的锁机制。
Lock锁可以通过lock()方法获取锁，并通过unlock()方法释放锁。
与synchronized相比，Lock锁具有更强的功能，比如可以实现公平锁、可重入锁等。
3. 使用volatile关键字：volatile关键字用于修饰变量，它可以保证变量的可见性和有序性。
当一个线程修改了被volatile修饰的变量时，其他线程可以立即看到这个变化。
这样可以保证多个线程对变量的读写操作是同步的。
4. 使用wait()和notify()方法：wait()方法可以使当前线程进入等待状态，直到其他线程调用notify()方法唤醒它。
这样可以实现线程间的协作和同步。
5. 使用Condition条件：Condition是Lock锁提供的一个条件类，它可以让线程在满足一定条件时等待或唤醒。
通过Condition条件，可以更加灵活地控制线程的等待和唤醒。
Android线程间同步的原理是通过上述机制来实现多个线程之间的互斥访问和同步操作。
当多个线程同时访问一个共享资源时，通过上述机制可以保证每个线程按照一定的顺序执行，避免出现数据竞争和并发问题。
在Android开发中，线程间同步非常重要，特别是在涉及到多线程访问共享资源的情况下。
synchronize的几种用法
synch ronize的几种用法简介在计算机编程中，"s y nc hr on iz e"（同步）是一个常用的关键词，用于描述不同线程或进程之间的协调和数据一致性。
在本文档中，将介绍s y nc hr on iz e关键词的几种常见用法，并为每种用法提供相应的示例。
一、同步块在多线程编程中，同步块是一种用于控制对共享资源的访问的方法。
通过在代码块前面添加`sy nc hr on iz ed`关键词，可以确保同一时间只有一个线程可以访问该代码块。
s y nc hr on iz ed(l ock O bj ec t){//在此处进行共享资源的操作}二、同步方法另一种常见的同步方法是使用`s yn ch ro ni z ed`关键词将方法声明为同步方法。
这意味着每次只能有一个线程执行该方法，其他线程将等待。
p u bl ic sy nc hr on ize d vo id so me Me th od(){//在此处进行操作}三、同步类除了同步代码块和同步方法之外，还可以使用`s yn ch ro ni zed`关键词同步类。
通过在方法签名前面添加`syn c hr on iz ed`关键词，可以确保同一时间只有一个线程可以访问该类的任何同步方法。
p u bl ic cl as sS yn chr o ni ze dC la ss{p u bl ic sy nc hr on ize d vo id me th od1(){//在此处进行操作}p u bl ic sy nc hr on ize d vo id me th od2(){//在此处进行操作}}四、同步关键字配合L o c k对象J a va中的`L oc k`对象也可以与`sy nc hro n iz e`关键字搭配使用，用于实现更细粒度的同步控制。
L o ck lo ck=n ew Re ent r an tL oc k();l o ck.l oc k();t r y{//在此处进行操作}f in al ly{l o ck.u nl oc k();}五、同步关键字配合信号量另一种使用`sy nc hro n iz e`关键字的方式是与信号量（S ema p ho re）搭配使用，用于协调并发访问的线程数量。
java synchronized的用法
在Java编程语言中，synchronized关键字是用于实现多线程同步的重要工具。
通过在代码块或方法前添加synchronized关键字，可以确保同一时刻只有一个线程可以进入该代码块或方法，从而避免多线程并发访问时可能出现的数据不一致或异常情况。
在本文中，我将从简到繁地探讨Java synchronized的用法，以帮助您更全面地理解这一重要的概念。
1. 普通锁方法在最简单的情况下，可以使用synchronized关键字来锁定整个方法，以确保同一时刻只有一个线程可以进入该方法。
例如：```javapublic synchronized void doSomething() {// 线程安全操作}```在这个例子中，方法doSomething()被标记为synchronized，因此在同一时刻只有一个线程可以调用该方法，从而避免了多线程并发访问时可能出现的问题。
2. 对象锁和类锁除了锁定整个方法外，还可以使用synchronized关键字来锁定对象或类。
在Java中，每个对象都有一个内置的锁，也称为对象监视器。
通过使用对象的锁，可以确保在同一时刻只有一个线程可以访问该对象的同步代码块。
例如：```javapublic void doSomething() {synchronized(this) {// 线程安全操作}}public static synchronized void doAnotherThing() {// 线程安全操作}```在这个例子中，第一个方法使用了对象锁，即通过synchronized(this)来锁定当前对象；第二个方法则使用了类锁，即通过在静态方法前添加synchronized关键字来锁定整个类。
这样可以确保在同一时刻只有一个线程可以访问相应的代码块，从而实现线程安全。
3. 临界区和锁对象在多线程编程中，临界区是指一段需要互斥访问的代码区域。
为了确保临界区的线程安全，可以使用锁对象来进行同步控制。
synchronized作用范围和用法
synchronized作用范围和用法synchronized是Java的关键字之一，用于实现多线程的同步控制。
它的作用是控制多线程对同一个共享资源的访问，以避免多线程并发操作导致的数据不一致或冲突问题。
synchronized可以应用于方法、代码块和静态方法，下面将详细讨论这些用法。
1. 方法级别的synchronized：在方法的声明中使用synchronized关键字可以实现对整个方法的同步控制。
当一个线程进入一个带有synchronized关键字的方法时，它会自动获得这个方法的锁，其他线程将被阻塞，直到该线程执行完方法并释放锁。
该方法在整个执行期间只能被一个线程访问，从而确保了线程安全。
2. 代码块级别的synchronized：除了整个方法级别，还可以在方法中使用synchronized关键字来限制某些代码块的访问。
使用synchronized代码块时，必须指定一个对象作为该代码块的锁。
当线程进入代码块时，它会尝试获得锁，如果锁被其他线程占用，则该线程将被阻塞，直到锁被释放。
可以使用任意非null的对象作为锁，只要不同的线程都能够访问到同一个锁对象。
3. 静态方法级别的synchronized：除了在实例方法级别上进行同步控制，synchronized还可以用于静态方法上。
使用synchronized关键字修饰的静态方法会对该静态方法所属的类对象进行加锁，即类锁。
与实例方法不同的是，类锁的作用范围是整个类，而不是该类的对象。
因此，即使多个线程访问不同的实例方法，如果这些方法都属于同一个类，它们也会相互阻塞。
synchronized的使用可以避免多线程环境下的数据竞争和不一致性，保证线程安全。
它可以控制对共享资源的访问、修改和更新，确保一次只有一个线程能够对共享资源进行操作，从而避免了互斥和并发访问导致的数据错误。
synchronized还具有可见性，当一个线程释放锁时，它会将最新的数据刷新到主内存，从而保证其他线程能够看到最新的数据。
java synchronized 使用方法
java synchronized 使用方法一、概述在Java中，synchronized关键字用于实现线程同步，即确保多个线程访问共享资源时能够协调一致。
synchronized关键字可以用于方法、代码块或对象上，以实现不同的同步效果。
本篇文章将介绍synchronized的基本用法、注意事项和高级用法。
二、基本用法1. 用于方法上：在方法声明中使用synchronized关键字，可以对该方法进行同步，即多个线程同时访问该方法时，只有一个线程能够进入执行。
其他线程需要等待该线程执行完毕后，才能进入该方法。
示例代码：```javapublic synchronized void synchronizedMethod() {// 实现同步的方法体}```2. 用于代码块上：在代码块前使用synchronized关键字，可以对该代码块进行同步。
多个线程同时访问该代码块时，也需要确保协调一致。
通常使用synchronized(对象)的形式，其中对象是该代码块所保护的资源。
示例代码：```javapublic void someMethod() {Object obj = this; // 指定所保护的资源对象synchronized(obj) {// 实现同步的代码块}}```三、注意事项1. synchronized不能用于静态方法上，因为静态方法是属于类级别的，而synchronized是对象级别的，两者不匹配。
2. synchronized用于方法或代码块上时，必须指定锁对象，即所保护的资源对象。
否则会导致线程同步混乱。
3. 避免在循环中使用synchronized，以避免死锁情况的发生。
4. synchronized只能保证同一时刻只有一个线程能够访问被同步的代码块或方法，但不能保证其他线程在等待进入被同步的方法时，能够获取到方法的执行权。
需要结合其他同步机制（如Lock、ReentrantLock等）来实现更精细的同步控制。
synchronized的使用方法
synchronized的使⽤⽅法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 块。
synchronize的用法
synchronize的用法Synchronize是一个关键词，它有多种语言中都能够找到它的存在。
在计算机领域中，synchronize是一个很常见的术语，而且在多线程程序中，使用synchronize是非常重要的。
下面将针对synchronize的用法作一些探讨。
1.概述synchronize是一种同步机制，它的作用是避免多个线程同时访问共享资源。
在多线程环境中，多个线程并发执行同一段代码时，可能会对共享资源进行读、写等操作，这样就会导致数据的不一致性和冲突。
如果不进行同步，就会导致程序的不可预料的行为和不正确的结果。
2.使用synchronize的方式Java中使用synchronize的方式有两种：synchronize方法和synchronize代码块。
（1）synchronize方法在Java中，可以在方法声明中使用synchronize关键字来同步方法，在方法前面加上synchronize关键字即可。
当一个线程获取了该方法的对象锁后，其他线程就必须等待该线程执行完该方法后才能再次获得该方法的对象锁。
这种方式适用于多个线程同时调用同一个类的实例方法时，需要把竞争控制在方法内部。
（2）synchronize代码块另一种方式是使用synchronize代码块，使用方式是在代码块之前加上synchronize关键字，并指定一个锁对象。
这种方式适用于多个线程同时访问同一段代码时需要把竞争控制在代码块内部。
3.锁的粒度选择锁的粒度是同步机制的一个重要问题。
锁的粒度越细，就越容易并发；锁的粒度越粗，就越能保证数据一致性。
因此，根据实际情况选择合适的锁的粒度是非常重要的。
在Java中，锁的粒度可以从最小的一个对象到整个类进行选择，锁的粒度越小，则锁定所需的时间也越短，程序的效率也就越高；锁的粒度越大，则数据的一致性就越容易得到保证。
4.死锁问题synchronize在多线程环境下确实是非常重要的同步机制，但是也会出现死锁问题。