java-同步机制-浅析 Synchronized
Synchronized 介绍
Synchronized 方面的文章网上有很多了。它主要是用来进行同步操作。也被称为重量级的锁,它的同步包括:
- 对于普通方法同步,锁是当前实例对象
- 对于静态方法同步,锁是当前类的 Class 对象
- 对于方法块同步,锁是 Synchronized 括号里的对象
上述都是对象级别的锁,当一个线程访问对象中的同步方法时,会获取到对象级别的锁,由于 Synchronized 内部是可重入的互斥锁,所以线程可再次重入用 Synchronized 修饰的方法,但当其它线程执行同一个对象的带有 Synchronized 的方法时,会被阻塞,即使和以持有对象锁的线程执行的相同对象的不同 Synchronized 方法。因为锁是对象级别的。比如线程 A、B。对象 Foo 有同步方法 M、N。线程 A 首先执行同步方法 M 时就会获取对象锁,此时 B 不能执行同一把对象锁修饰的方法 M、N。除非 A 释放锁。又因为锁是可重入的,所以 A 可以继续执行 M,N 方法。可重入锁一定程度上避免了死锁的问题,内部是关联一个计数器,加一次锁计数器值加一,为零时释放锁。
那么如何理解锁是“对象”。
Java 编程语言中号称一切皆对象。当我们 new 一个对象的时候 JVM 会给 heap 中分配对象。如下图:
对象头 这个头包括两个部分,第一部分用于存储自身运行时的数据例如GC标志位、哈希码、锁状态 等信息。第二部分存放指向方法区类静态数据的指针。锁状态 就是用来同步操作的 bit 位。因为锁信息是存储在对象上的,所以就不难理解 锁是对象 这句话了。
synchronized 是java语言关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。
本文直接以代码的形式来展示 synchronized 关键字的使用:
【1】synchronized Demo1:
- package com.andyidea.demo;
- /**
- * 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,
- * 一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码
- * 块以后才能执行该代码块。
- * @author Andy.Chen
- *
- */
- public class Thread01 implements Runnable {
- @Override
- public void run() {
- synchronized (this) {
- for(int i=0;i<3;i++){
- System.out.println(Thread.currentThread().getName()+" synchronized loop "+i);
- }
- }
- }
- public static void main(String[] args) {
- Thread01 t01 = new Thread01();
- System.out.println("Welcome to Andy.Chen Blog! \n"
- +"synchronized 关键字使用 \n"
- +"--------------------------");
- Thread ta = new Thread(t01,"A");
- Thread tb = new Thread(t01,"B");
- ta.start();
- tb.start();
- }
- }
运行结果如下:
- Welcome to Andy.Chen Blog!
- synchronized 关键字使用
- --------------------------
- B synchronized loop 0
- B synchronized loop 1
- B synchronized loop 2
- A synchronized loop 0
- A synchronized loop 1
- A synchronized loop 2
【2】synchronized Demo2:
- package com.andyidea.demo;
- /**
- * 当一个线程访问object的一个synchronized(this)同步代码块时,
- * 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
- * @author Andy.Chen
- *
- */
- public class Thread02 {
- public void method01(){
- synchronized (this) {
- int i=0;
- while(i++ < 3){
- System.out.println(Thread.currentThread().getName() +":"+ i);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- public void method02(){
- //第1种方式:当一个线程访问object的一个synchronized(this)同步代码块时,
- //另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
- // int j=0;
- // while(j++ < 3){
- // System.out.println(Thread.currentThread().getName() +":"+ j);
- // try {
- // Thread.sleep(1000);
- // } catch (InterruptedException e) {
- // e.printStackTrace();
- // }
- // }
- //第2种方式:当一个线程访问object的一个synchronized(this)同步代码块时,
- //其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
- synchronized (this) {
- int j=0;
- while(j++ < 3){
- System.out.println(Thread.currentThread().getName() +":"+ j);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- /**
- * 当一个线程访问object的一个synchronized(this)同步代码块时,
- * 它就获得了这个object的对象锁。
- * 结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
- */
- public synchronized void method3(){
- int k=0;
- while(k++ < 3){
- System.out.println(Thread.currentThread().getName() +":"+ k);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- public static void main(String[] args) {
- final Thread02 t02 = new Thread02();
- System.out.println("Welcome to Andy.Chen Blog! \n"
- +"synchronized 关键字使用 \n"
- +"--------------------------");
- Thread t02A = new Thread(new Runnable() {
- @Override
- public void run() {
- t02.method01();
- }
- },"A");
- Thread t02B = new Thread(new Runnable() {
- @Override
- public void run() {
- t02.method02();
- }
- },"B");
- Thread t02C = new Thread(new Runnable() {
- @Override
- public void run() {
- t02.method3();
- }
- },"C");
- t02A.start();
- t02B.start();
- t02C.start();
- }
- }
- Welcome to Andy.Chen Blog!
- synchronized 关键字使用
- --------------------------
- B:1
- B:2
- B:3
- C:1
- C:2
- C:3
- A:1
- A:2
- A:3
- package com.andyidea.demo;
- /**
- * synchronized对象锁
- * @author Andy.Chen
- *
- */
- public class Thread03 {
- class InnerObject{
- /**
- * 内部类方法1
- */
- private void innerMethod01(){
- int i=0;
- while(i++ < 3){
- System.out.println(Thread.currentThread().getName() +":"+ i);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- /**
- * 内部类方法2
- */
- private void innerMethod02(){
- int j=0;
- while(j++ < 3){
- System.out.println(Thread.currentThread().getName() +":"+ j);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- /**
- * 外部类方法1
- * @param innerObj
- */
- private void outerMethod01(InnerObject innerObj){
- synchronized (innerObj) {
- innerObj.innerMethod01();
- }
- }
- /**
- * 外部类方法2
- * @param innerObj
- */
- private void outerMethod02(InnerObject innerObj){
- innerObj.innerMethod02();
- }
- public static void main(String[] args) {
- final Thread03 t03 = new Thread03();
- final InnerObject innerObj = t03.new InnerObject();
- System.out.println("Welcome to Andy.Chen Blog! \n"
- +"synchronized 关键字使用 \n"
- +"--------------------------");
- Thread t03A = new Thread(new Runnable() {
- @Override
- public void run() {
- t03.outerMethod01(innerObj);
- }
- },"A");
- Thread t03B = new Thread(new Runnable() {
- @Override
- public void run() {
- t03.outerMethod02(innerObj);
- }
- },"B");
- t03A.start();
- t03B.start();
- }
- }
- Welcome to Andy.Chen Blog!
- synchronized 关键字使用
- --------------------------
- A:1
- B:1
- B:2
- A:2
- B:3
- A:3
总结:
1. synchronized 方法控制对类成员变量的访问:每个类实例对应一把锁,每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行,否则所属线程阻塞,方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例,其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁),从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为 synchronized)。
2. synchronized 块是这样一个代码块,其中的代码必须获得对象 syncObject (如前所述,可以是类实例或类)的锁方能执行。由于可以针对任意代码块,且可任意指定上锁的对象,故灵活性较高。
对synchronized(this)的一些理解
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
四、当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
请参考:http://blog.****.net/cjjky/article/details/7353390
http://blog.****.net/wwh578867817/article/details/52004265