synchronized 详解

前言

艰深：造成线程平安问题的次要诱因有两点：

• 存在共享数据(也称临界资源)
• 存在多条线程独特操作共享数据

学术：造成线程平安问题的次要诱因有两点：

• 主内存和线程的工作内存而导致的 内存可见性问题，
• 重排序导致的问题，须要晓得happens-before 规定。

当存在多个线程操作共享数据时，须要保障同一时刻有且只有一个线程在操作共享数据，其余线程必须等到该线程解决完数据后再进行，这种形式的名称叫·互斥锁，也就是说当一个共享数据被以后正在拜访的线程加上互斥锁后，在同一个时刻，其余线程只能处于期待的状态，直到以后线程处理完毕开释该锁。

关键字 synchronized能够保障（1）在同一个时刻，只有一个线程能够执行某个办法或者某个代码块 (次要是对办法或者代码块中存在共享数据的操作)，（2）synchronized 保障一个线程的变动(次要是共享数据的变动) 被其余线程所看到（保障可见性，齐全能够代替 Volatile 性能）也就是happens-before 规定。

标注：在学习中须要批改的内容以及笔记全在这里 www.javanode.cn，谢谢！有任何不妥的中央望纠正

synchronized 次要形式

synchronized 关键字最次要有以下 3 种利用形式，上面别离介绍

• 润饰实例办法，作用于以后实例加锁，进入同步代码前要取得以后 实例 的锁
• 润饰静态方法，作用于以后类对象加锁，进入同步代码前要取得 以后类对象 的锁
• 润饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要取得 给定对象的锁。

synchronized 应用

作用于实例办法

所谓的 实例对象锁 就是用synchronized 润饰实例对象中的实例办法，留神是实例办法不包含静态方法

public class AccountingSync implements Runnable{// 共享资源(临界资源)
    static int i=0;

    /**
     * synchronized 润饰实例办法
     */
    public synchronized void increase(){i++;}
    @Override
    public void run() {for(int j=0;j<1000000;j++){increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
    /**
     * 输入后果:
     * 2000000
     */
}

咱们应该留神到 synchronized 润饰的是实例办法 increase，在这样的状况下，以后线程的锁便是实例对象 instance，留神Java 中的线程同步锁能够是任意对象。

这里咱们还须要意识到，当一个线程正在拜访一个对象的 synchronized 实例办法，那么其余线程不能拜访该对象的其余 synchronized 办法，毕竟 一个对象只有一把锁 ，当一个线程获取了该对象的锁之后，其余线程无奈获取该对象的锁，所以无法访问该对象的其余 synchronized 实例办法，然而其余线程还是能够拜访该实例对象的其余非 synchronized 办法，当然如果是一个线程 A 须要拜访实例对象 obj1 的 synchronized 办法 f1(以后对象锁是 obj1)，另一个线程 B 须要拜访实例对象 obj2 的 synchronized 办法 f2(以后对象锁是 obj2)，这样是容许的，因为两个实例对象锁并不同雷同，此时 如果两个线程操作数据并非共享的，线程平安是有保障的，

遗憾的是如果 两个线程操作的是共享数据，那么线程平安就有可能无奈保障 了，如下代码将演示出该景象

public class AccountingSyncBad implements Runnable{
    static int i=0;
    public synchronized void increase(){i++;}
    @Override
    public void run() {for(int j=0;j<1000000;j++){increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new 新实例
        Thread t1=new Thread(new AccountingSyncBad());
        //new 新实例
        Thread t2=new Thread(new AccountingSyncBad());
        t1.start();
        t2.start();
        //join 含意: 以后线程 A 期待 thread 线程终止之后能力从 thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

上述代码与后面不同的是咱们同时创立了两个新实例 AccountingSyncBad，而后启动两个不同的线程对共享变量 i 进行操作，但很遗憾操作后果是 1452317 而不是冀望后果 2000000，因为上述代码犯了重大的谬误，尽管咱们应用 synchronized 润饰了 increase 办法，但却new 了两个不同的实例对象，这也就意味着 存在着两个不同的实例对象锁，因而t1 和 t2 都会进入各自的对象锁，也就是说 t1 和 t2 线程应用的是不同的锁，因而线程平安是无奈保障的。解决这种窘境的的形式是将synchronized 作用于动态的 increase 办法，这样的话，对象锁就以后类对象，因为无论创立多少个实例对象，但对于的类对象领有只有一个，所有在这样的状况下对象锁就是惟一的。上面咱们看看如何应用将 synchronized 作用于动态的 increase 办法。

作用于静态方法

当 synchronized 作用于静态方法时，其锁就是以后类的 class 对象锁。因为动态成员不专属于任何一个实例对象，是类成员，因而通过 class 对象锁能够管制动态 成员的并发操作。须要留神的是如果一个线程 A 调用一个实例对象的非 static synchronized 办法，而线程 B 须要调用这个实例对象所属类的动态 synchronized 办法，是容许的，不会产生互斥景象，因为拜访动态 synchronized 办法占用的锁是以后类的 class 对象，而拜访非动态 synchronized 办法占用的锁是以后实例对象锁，看如下代码

public class AccountingSyncClass implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法, 锁是以后 class 对象, 也就是
     * AccountingSyncClass 类对应的 class 对象
     */
    public static synchronized void increase(){i++;}

    /**
     * 非动态, 拜访时锁不一样不会产生互斥
     */
    public synchronized void increase4Obj(){i++;}

    @Override
    public void run() {for(int j=0;j<1000000;j++){increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new 新实例
        Thread t1=new Thread(new AccountingSyncClass());
        //new 心事了
        Thread t2=new Thread(new AccountingSyncClass());
        // 启动线程
        t1.start();t2.start();

        t1.join();t2.join();
        System.out.println(i);
    }
}

因为 synchronized 关键字润饰的是动态 increase 办法，与润饰实例办法不同的是，其锁对象是以后类的 class 对象。留神代码中的 increase4Obj 办法是实例办法，其对象锁是以后实例对象，如果别的线程调用该办法，将不会产生互斥景象，毕竟锁对象不同，但咱们应该意识到这种状况下可能会发现线程平安问题(操作了共享动态变量 i)。

作用于同步代码块

除了应用关键字润饰实例办法和静态方法外，还能够应用同步代码块，在某些状况下，咱们编写的办法体可能比拟大，同时存在一些比拟耗时的操作，而须要同步的代码又只有一小部分，如果间接对整个办法进行同步操作，可能会得失相当，此时咱们能够应用同步代码块的形式对须要同步的代码进行包裹，这样就无需对整个办法进行同步操作了，同步代码块的应用示例如下：

public class AccountingSync implements Runnable{static AccountingSync instance=new AccountingSync();
    static int i=0;
    @Override
    public void run() {
        // 省略其余耗时操作....
        // 应用同步代码块对变量 i 进行同步操作, 锁对象为 instance
        synchronized(instance){for(int j=0;j<1000000;j++){i++;}
        }
    }
    public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

从代码看出，将 synchronized 作用于一个给定的实例对象 instance，即 以后实例对象就是锁对象 ，每次当线程进入 synchronized 包裹的代码块时就会要求以后线程持有 instance 实例对象锁，如果以后有其余线程正持有该对象锁，那么新到的线程就必须期待，这样也就保障了每次只有一个线程执行i++; 操作。当然除了 instance 作为对象外。

咱们还能够应用 this 对象(代表以后实例) 或者以后类的 class 对象作为锁，如下代码：

//this, 以后实例对象锁
synchronized(this){for(int j=0;j<1000000;j++){i++;}
}

//class 对象锁
synchronized(AccountingSync.class){for(int j=0;j<1000000;j++){i++;}
}

总结

synchronized 锁对象和锁类是实质都是对对象来加锁。类也是一个非凡的对象。只不过类对象只有一个。对象内锁不同的属性，两个同步办法能够同时拜访

synchronized 底层语义原理

在 JVM 中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充。如下：

对象头由mark word，指向对象实例数据的指针(Class Metadata Address)，length 组成，其构造阐明如下表：

其中 Mark Word 在默认状况下存储着对象的 HashCode、分代年龄、锁标记位等以下是 32 位 JVM 的 Mark Word 默认存储构造

因为对象头的信息是与对象本身定义的数据没有关系的额定存储老本，因而思考到 JVM 的空间效率，Mark Word 被设计成为一个非固定的数据结构，以便存储更多无效的数据，它会依据对象自身的状态复用本人的存储空间，

synchronized 代码块底层原理

Java 虚拟机中的 同步 (Synchronization) 基于进入和退出管程 (Monitor) 对象实现 ，无论是显式同步(有明确的 monitorenter 和 monitorexit 指令, 即同步代码块) 还是隐式同步 (办法级的同步) 都是如此。在 Java 语言中，同步用的最多的中央可能是被 synchronized 润饰的同步办法。同步办法 并不是由 monitorenter 和 monitorexit 指令来实现同步的，而是由办法调用指令读取运行时常量池中办法的 ACC_SYNCHRONIZED 标记来隐式实现的，

深刻 JVM 看字节码，创立如下的代码：

public class SynchronizedDemo2 {Object object = new Object();
    public void method1() {synchronized (object) {}}
}

从字节码中可知 同步语句块 的实现应用的是 monitorenter 和 monitorexit 指令。这也是添 Synchronized 关键字之后独有的。执行同步代码块首先要先执行monitorenter 指令，退出的时候是 monitorexit 指令。应用 Synchronized 进行同步，其要害就是 必须要对对象的监视器 monitor 进行获取 ，当执行 monitorenter 指令时，<u> 以后线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权，当 objectref 的 monitor 的进入计数器为 0，那线程能够胜利获得 monitor，并将计数器值设置为 1，</u> 取锁胜利。Synchronized 先天具备重入性。如果以后线程曾经领有 objectref 的 monitor 的持有权，那它能够重入这个 monitor (对于重入性稍后会剖析)，重入时计数器的值也会加 1。假使其余线程曾经领有 objectref 的 monitor 的所有权，那以后线程将被阻塞，直到正在执行线程执行结束，即 monitorexit 指令被执行，执行线程将开释 monitor(锁) 并设置计数器值为 0，其余线程将有机会持有 monitor。值得注意的是编译器将会确保无论办法通过何种形式实现，办法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令，而无论这个办法是失常完结还是异样完结。为了保障在办法异样实现时 monitorenter 和 monitorexit 指令仍然能够正确配对执行，<u> 编译器会主动产生一个 异样处理器，这个异样处理器申明可解决所有的异样，它的目标就是用来执行 monitorexit 指令。</u> 从字节码中也能够看出多了一个 monitorexit 指令，它就是异样完结时被执行的开释 monitor 的指令。

synchronized 办法底层原理

办法级的同步是隐式 ，即无需通过字节码指令来管制的，它实现在办法调用和返回操作之中。JVM 能够从办法常量池中的办法表构造(method_info Structure) 中的 ACC_SYNCHRONIZED 拜访标记辨别一个办法是否同步办法。当办法调用时，调用指令将会 查看办法的 ACC_SYNCHRONIZED 拜访标记是否被设置，如果设置了，执行线程将先持有 monitor（虚拟机标准中用的是管程一词），而后再执行办法，最初再办法实现(无论是失常实现还是非正常实现) 时开释 monitor。在办法执行期间，执行线程持有了 monitor，其余任何线程都无奈再取得同一个 monitor。如果一个同步办法执行期间抛出了异样，并且在办法外部无奈解决此异样，那这个同步办法所持有的 monitor 将在异样抛到同步办法之外时主动开释。

// 办法级的同步是隐式，public class SyncMethod {

        public int i;

        public synchronized void syncTask(){i++;}

    }

  ## 反编译当前的字节码
  public synchronized void syncTask();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #2                  // Field i:I
         5: iconst_1
         6: iadd
         7: putfield      #2                  // Field i:I
        10: return
      LineNumberTable:
        line 9: 0
        line 10: 10
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcn/javanode/concurrent/key/synchronizedDesc/SyncMethod;
}

从字节码中能够看出，<u>synchronized 润饰的办法并没有 monitorenter 指令和 monitorexit 指令，获得代之的的确是 ACC_SYNCHRONIZED 标识，该标识指明了该办法是一个同步办法 </u>，JVM 通过该 ACC_SYNCHRONIZED 拜访标记来分别一个办法是否申明为同步办法，从而执行相应的同步调用。这便是 synchronized 锁在同步代码块和同步办法上实现的基本原理。同时咱们还必须留神到的是在 Java 晚期版本中，synchronized 属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，而操作系统实现线程之间的切换时须要从用户态转换到外围态，这个状态之间的转换须要绝对比拟长的工夫，工夫老本绝对较高，这也是为什么晚期的 synchronized 效率低的起因。庆幸的是在 Java 6 之后 Java 官网对从 JVM 层面对 synchronized 较大优化，所以当初的 synchronized 锁效率也优化得很不错了，Java 6 之后，为了缩小取得锁和开释锁所带来的性能耗费，引入了轻量级锁和偏差锁。

Java 虚拟机对 synchronized 的优化

锁的状态总共有四种，无锁状态、偏差锁、轻量级锁和重量级锁。随着锁的竞争，锁能够从偏差锁降级到轻量级锁，再降级的重量级锁，然而锁的降级是单向的，也就是说只能从低到高降级，不会呈现锁的降级，

无锁

能够看到 mark word 外面此时存了

• 锁状态
• 对象的 hashcode
• 对象的分代年龄，这里用于垃圾回收
• 是否偏差锁：0 否 1 是
• 锁标记位：01

偏差锁

在 jdk1.6 后被提出：在大多数状况下，锁并不存在竞争，<u> 一把锁往往是同一个线程取得的，并不需要加锁和解锁 </u>。因而为了缩小同一线程获取锁 (会波及到一些 CAS 操作, 耗时) 的代价而引入 偏差锁 。 偏差锁的核心思想是，如果一个线程取得了锁，那么锁就进入偏差模式，此时 Mark Word 的构造也变为偏差锁构造，当这个线程再次申请锁时，无需再做任何同步操作，即获取锁的过程，这样就省去了大量无关锁申请的操作，从而也就提供程序的性能。所以，对于没有锁竞争的场合，偏差锁有很好的优化成果，毕竟极有可能间断屡次是同一个线程申请雷同的锁。然而对于锁竞争比拟强烈的场合，偏差锁就生效了，因为这样场合极有可能每次申请锁的线程都是不雷同的，因而这种场合下不应该应用偏差锁，否则会得失相当，须要留神的是，偏差锁失败后，并不会立刻收缩为重量级锁，而是先降级为轻量级锁。

轻量级锁

假使偏差锁失败，虚拟机并不会立刻降级为重量级锁，它还会尝试应用一种称为轻量级锁的优化伎俩 (1.6 之后退出的)，此时 Mark Word 的构造也变为轻量级锁的构造。轻量级锁可能晋升程序性能的根据是“对绝大部分的锁，在整个同步周期内都不存在竞争”，留神这是教训数据。须要理解的是， 轻量级锁所适应的场景是线程交替执行同步块的场合，如果存在同一时间拜访同一锁的场合，就会导致轻量级锁收缩为重量级锁。

自旋锁

轻量级锁失败后，虚拟机为了防止线程实在地在操作系统层面挂起，还会进行一项称为自旋锁的优化伎俩。这是基于在大多数状况下，线程持有锁的工夫都不会太长，如果间接挂起操作系统层面的线程可能会得失相当，毕竟操作系统实现线程之间的切换时须要从用户态转换到外围态，这个状态之间的转换须要绝对比拟长的工夫，工夫老本绝对较高，因而自旋锁会假如在不久未来，以后的线程能够取得锁，因而虚构机会让以后想要获取锁的线程做几个空循环(这也是称为自旋的起因)，个别不会太久，可能是 50 个循环或 100 循环，在通过若干次循环后，如果失去锁，就顺利进入临界区。如果还不能取得锁，那就会将线程在操作系统层面挂起，这就是自旋锁的优化形式，这种形式的确也是能够晋升效率的。最初没方法也就只能降级为重量级锁了。

锁打消

打消锁是虚拟机另外一种锁的优化，这种优化更彻底，<u>Java 虚拟机在 JIT 编译时(能够简略了解为当某段代码行将第一次被执行时进行编译，又称即时编译)，通过对运行上下文的扫描，去除不可能存在共享资源竞争的锁，通过这种形式打消没有必要的锁 </u>，能够节俭毫无意义的申请锁工夫，如下 StringBuffer 的 append 是一个同步办法，然而在 add 办法中的 StringBuffer 属于一个局部变量，并且不会被其余线程所应用，因而 StringBuffer 不可能存在共享资源竞争的情景，JVM 会主动将其锁打消。

/**
 * 打消 StringBuffer 同步锁
 */
public class StringBufferRemoveSync {public void add(String str1, String str2) {
        //StringBuffer 是线程平安, 因为 sb 只会在 append 办法中应用, 不可能被其余线程援用
        // 因而 sb 属于不可能共享的资源,JVM 会主动打消外部的锁
        StringBuffer sb = new StringBuffer();
        sb.append(str1).append(str2);
    }

    public static void main(String[] args) {StringBufferRemoveSync rmsync = new StringBufferRemoveSync();
        for (int i = 0; i < 10000000; i++) {rmsync.add("abc", "123");
        }
    }

}

锁的优缺点比照

补充知识点

1.synchronized 的可重入性

从互斥锁的设计上来说，当一个线程试图操作一个由其余线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次申请本人持有对象锁的临界资源时，这种状况属于重入锁，申请将会胜利，在 java 中 synchronized 是基于原子性的外部锁机制，是可重入的，因而在 一个线程调用 synchronized 办法的同时在其办法体外部调用该对象另一个 synchronized 办法，也就是说一个线程失去一个对象锁后再次申请该对象锁，是容许的，这就是 synchronized 的可重入性。如下：

public class AccountingSync implements Runnable{static AccountingSync instance=new AccountingSync();
    static int i=0;
    static int j=0;
    @Override
    public void run() {for(int j=0;j<1000000;j++){

            //this, 以后实例对象锁
            synchronized(this){
                i++;
                increase();//synchronized 的可重入性}
        }
    }

    public synchronized void increase(){j++;}


    public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

在获取以后实例对象锁后进入 synchronized 代码块执行同步代码，并在代码块中调用了以后实例对象的另外一个 synchronized 办法，再次申请以后实例锁时，将被容许，进而执行办法体代码，这就是重入锁最间接的体现，须要特地留神另外一种状况，当子类继承父类时，子类也是能够通过可重入锁调用父类的同步办法。留神因为 synchronized 是基于 monitor 实现的，因而每次重入，monitor 中的计数器仍会加 1。

2.synchronized 实现可见性的原理

简略地说 可见性就是把工作内存中的数据刷入主内存，加载数据。具体到内存屏障

int b = 0;

 int c = 0;

 synchronized(this) { -> monitorenter 

    Load 内存屏障 
    Acquire 内存屏障 

    int a = b; 
    c = 1; => synchronized 代码块外面还是可能会产生指令重排 

    Release 内存屏障 
} -> monitorexit 

Store 内存屏障 

• Load 屏障的作用是执行 refresh 处理器缓存的操作，说白了就是对别的处理器更新过去变量，从 其余处理器的高速缓存（或者主内存）加载数据到本人的高速缓存来，确保本人看到的是最新的数据。
• Store 屏障的作用是执行 flush 处理器缓存的操作，说白了就是把本人以后 处理器更新的变量的值，都刷新到高速缓存（或者主内存）里去

基于 synchronized 代码块字节码层面上来说：

• 在 moniterenter 指令之后，退出了一个 load 屏障，执行一个 refresh 操作从其余处理器的高速缓存读取最新数据或者从主内存加载数据
• 在 moniterexit 指令之后，退出一个 store 屏障，执行 flush 操作，把最新值写入高速缓存或者主内存

3.synchronized 实现有序性的原理

如下面代码所示

• 在 monitorenter 指令之后，Load 屏障之后，会加一个 Acquire 屏障，这个 屏障的作用是禁止读操作和读写操作之间产生指令重排序。
• 在 monitorexit 指令之前，会加一个 Release 屏障，这个 屏障的作用是禁止写操作和读写操作之间产生重排序。

所以说，通过 Acquire 屏障和 Release 屏障，就能够让 synchronzied 保障有序性，只有 synchronized 外部的指令能够重排序，然而相对 不会跟内部的指令产生重排序。

坚固晋升

找了几个例子, 坚固一下下面学的，看一下能不能想进去执行程序呢！

案例一

public class SynchronizedObjectLock implements Runnable {static SynchronizedObjectLock instence = new SynchronizedObjectLock();

    @Override
    public void run() {
        // 同步代码块模式——锁为 this, 两个线程应用的锁是一样的, 线程 1 必须要等到线程 0 开释了该锁后，能力执行
        synchronized (this) {System.out.println("我是线程" + Thread.currentThread().getName());
            try {Thread.sleep(3000);
            } catch (InterruptedException e) {e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "完结");
        }
    }

    public static void main(String[] args) {Thread t1 = new Thread(instence);
        Thread t2 = new Thread(instence);
        t1.start();
        t2.start();}
}
 
//    执行后果
/**
我是线程 Thread-0
Thread- 0 完结
我是线程 Thread-1
Thread- 1 完结
**/

案例二

public class SynchronizedObjectLock implements Runnable {static SynchronizedObjectLock instence = new SynchronizedObjectLock();
    // 创立 2 把锁
    Object block1 = new Object();
    Object block2 = new Object();

    @Override
    public void run() {
        // 这个代码块应用的是第一把锁，当他开释后，前面的代码块因为应用的是第二把锁，因而能够马上执行
        synchronized (block1) {System.out.println("block1 锁, 我是线程" + Thread.currentThread().getName());
            try {Thread.sleep(3000);
            } catch (InterruptedException e) {e.printStackTrace();
            }
            System.out.println("block1 锁,"+Thread.currentThread().getName() + "完结");
        }

        synchronized (block2) {System.out.println("block2 锁, 我是线程" + Thread.currentThread().getName());
            try {Thread.sleep(3000);//sleep 办法并不会失去锁。} catch (InterruptedException e) {e.printStackTrace();
            }
            System.out.println("block2 锁,"+Thread.currentThread().getName() + "完结");
        }
    }

    public static void main(String[] args) {Thread t1 = new Thread(instence);
        Thread t2 = new Thread(instence);
        t1.start();
        t2.start();}
}
  
//    执行后果
/**
block1 锁, 我是线程 Thread-0
block1 锁,Thread- 0 完结
block2 锁, 我是线程 Thread-0    // 能够看到当第一个线程在执行完第一段同步代码块之后，第二个同步代码块能够马上失去执行，因为他们应用的锁不是同一把
block1 锁, 我是线程 Thread-1
block1 锁,Thread- 1 完结
block2 锁,Thread- 0 完结
block2 锁, 我是线程 Thread-1
block2 锁,Thread- 1 完结
**/

办法锁模式：synchronized 润饰一般办法，锁对象默认为 this

// 以后线程的锁便是实例对象
// 当一个线程获取了该对象的锁之后，其余线程无奈获取该对象的锁，所以无法访问该对象的其余 synchronized 实例办法
public class SynchronizedObjectLock implements Runnable {static SynchronizedObjectLock instence = new SynchronizedObjectLock();

    @Override
    public void run() {method();
    }

    public synchronized void method() {System.out.println("我是线程" + Thread.currentThread().getName());
        try {Thread.sleep(3000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完结");
    }

    public static void main(String[] args) {Thread t1 = new Thread(instence);
        Thread t2 = new Thread(instence);
        t1.start();
        t2.start();}
}
  
//    执行后果
/**
我是线程 Thread-1
Thread- 1 完结
我是线程 Thread-0
Thread- 0 完结
**/

办法锁模式：synchronized 润饰一般办法，锁对象默认为 this

//t1 和 t2 对应的 this 是两个不同的实例，持有锁不同 一般锁只是以后实例
public class SynchronizedObjectLock implements Runnable {static SynchronizedObjectLock instence1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instence2 = new SynchronizedObjectLock();

    @Override
    public void run() {method();
    }

    // synchronized 用在一般办法上，默认的锁就是 this，以后实例
    public synchronized void method() {System.out.println("我是线程" + Thread.currentThread().getName());
        try {Thread.sleep(3000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完结");
    }

    public static void main(String[] args) {
        // t1 和 t2 对应的 this 是两个不同的实例，所以代码不会串行
        Thread t1 = new Thread(instence1);
        Thread t2 = new Thread(instence2);
        t1.start();
        t2.start();}
}
  
//    执行后果
/**
我是线程 Thread-0
我是线程 Thread-1
Thread- 1 完结
Thread- 0 完结
**/

类锁模式

public class SynchronizedObjectLock implements Runnable {static SynchronizedObjectLock instence1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instence2 = new SynchronizedObjectLock();

    @Override
    public void run() {method();
    }

    // synchronized 用在静态方法上，默认的锁就是以后所在的 Class 类，所以无论是哪个线程拜访它，须要的锁都只有一把
    public static synchronized void method() {System.out.println("我是线程" + Thread.currentThread().getName());
        try {Thread.sleep(3000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完结");
    }

    public static void main(String[] args) {Thread t1 = new Thread(instence1);
        Thread t2 = new Thread(instence2);
        t1.start();
        t2.start();}
}
//    执行后果
/**
我是线程 Thread-0
Thread- 0 完结
我是线程 Thread-1
Thread- 1 完结
**/

同步代码块

public class SynchronizedObjectLock implements Runnable {static SynchronizedObjectLock instence1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instence2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        // 所有线程须要的锁都是同一把
        synchronized(SynchronizedObjectLock.class){System.out.println("我是线程" + Thread.currentThread().getName());
            try {Thread.sleep(3000);
            } catch (InterruptedException e) {e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "完结");
        }
    }

    public static void main(String[] args) {Thread t1 = new Thread(instence1);
        Thread t2 = new Thread(instence2);
        t1.start();
        t2.start();}
}
//    执行后果
/**
我是线程 Thread-0
Thread- 0 完结
我是线程 Thread-1
Thread- 1 完结
**/

标注：在学习中须要批改的内容以及笔记全在这里 www.javanode.cn，谢谢！有任何不妥的中央望纠正