Java Synchronized关键字详解

转载 2018年04月16日 20:58:31

Java Synchronized关键字详解

原文链接:https://blog.csdn.net/luoweifu/article/details/46613015

概述

synchronized是java中的关键字,它是一种同步锁。修饰的对象有以下几种:
1、修饰代码块。被修饰的代码块称为同步语句块,作用域为大括号{}括起来的代码,作用的对象是调用这段代码块的对象。
2. 修饰方法。被修饰的方法称为同步方法,其作用域为整个方法,作用的对象是调用这个方法的对象。 
3. 修改静态方法。其作用域为整个静态方法,作用的对象是这个类生成的所有对象。 
4. 修饰类。作用域为synchronized后面括起来的部分,作用的对象是这个类的所有对象。

代码举例

1、一个线程访问一个对象的synchronized(this)同步代码块时,其他试图访问该对象的线程将被阻塞。示例如下:
    class SyncThread implements Runnable {
        private static int count;
        public SyncThread() {
            count = 0;
        }

        public void run() {
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "-" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public int getCount() {
            return count;
        }
    }

    public class Synchronized_1 {
        public static void main(String[] args) {
            SyncThread syncThread = new SyncThread();
            Thread thread1 = new Thread(syncThread, "SyncThread1");
            Thread thread2 = new Thread(syncThread, "SyncThread2");
            thread1.start();
            thread2.start();
        }
    }
    结果为:
        SyncThread1-0
        SyncThread1-1
        SyncThread1-2
        SyncThread1-3
        SyncThread1-4
        SyncThread2-5
        SyncThread2-6
        SyncThread2-7
        SyncThread2-8
        SyncThread2-9
        当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时,在同一
    时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。
    Thread1和thread2是互斥的,因为在执行synchronized代码块时会锁定当前的对象,只有执行完该代码块才能释
    放该对象锁,下一个线程才能执行并锁定该对象。 
        我们再把SyncThread的调用稍微改一下:
    Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
    Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
    thread1.start();
    thread2.start();
    结果为:
        SyncThread1-0
        SyncThread2-1
        SyncThread2-2
        SyncThread1-3
        SyncThread2-4
        SyncThread1-5
        SyncThread2-6
        SyncThread1-7
        SyncThread2-8
        SyncThread1-9
    不是说一个线程执行synchronized代码块时其它的线程受阻塞吗?为什么上面的例子中thread1和thread2同时在执
行。这是因为synchronized只锁定对象,每个对象只有一个锁(lock)与之相关联,而上面的代码等同于下面这段代码:
    SyncThread syncThread1 = new SyncThread();
    SyncThread syncThread2 = new SyncThread();
    Thread thread1 = new Thread(syncThread1, "SyncThread1");
    Thread thread2 = new Thread(syncThread2, "SyncThread2");
    thread1.start();
    thread2.start();
    这时创建了两个SyncThread的对象syncThread1和syncThread2,线程thread1执行的是syncThread1对象中的
synchronized代码(run),而线程thread2执行的是syncThread2对象中的synchronized代码(run);我们知道
synchronized锁定的是对象,这时会有两把锁分别锁定syncThread1对象和syncThread2对象,而这两把锁是互不干扰
的,不形成互斥,所以两个线程可以同时执行。
2、当一个线程访问对象的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该对象中的非synchronized(this)
代码块。示例如下:
    class Counter implements Runnable{
       private int count;

       public Counter() {
          count = 0;
       }

       public void countAdd() {
          synchronized(this) {
             for (int i = 0; i < 5; i ++) {
                try {
                   System.out.println(Thread.currentThread().getName() + ":" + (count++));
                   Thread.sleep(100);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
             }
          }
       }

       //非synchronized代码块,未对count进行读写操作,所以可以不用synchronized
       public void printCount() {
          for (int i = 0; i < 5; i ++) {
             try {
                System.out.println(Thread.currentThread().getName() + " count:" + count);
                Thread.sleep(100);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
          }
       }

       public void run() {
          String threadName = Thread.currentThread().getName();
          if (threadName.equals("A")) {
             countAdd();
          } else if (threadName.equals("B")) {
             printCount();
          }
       }
    }

    public class Synchronized_3 {
        public static void main(String[] args) {
            Counter counter = new Counter();
            Thread thread1 = new Thread(counter, "A");
            Thread thread2 = new Thread(counter, "B");
            thread1.start();
            thread2.start();
        }
    }
    结果为:
        A:0
        B count:1
        A:1
        B count:1
        B count:2
        A:2
        B count:3
        A:3
        B count:4
        A:4
    上面代码中countAdd是一个synchronized的,printCount是非synchronized的。从上面的结果中可以看出一个
线程访问一个对象的synchronized代码块时,别的线程可以访问该对象的非synchronized代码块而不受阻塞。
3、指定要给某个对象加锁。示例如下:
/**
     * 银行账户类
     */
    class Account {
       String name;
       float amount;

       public Account(String name, float amount) {
          this.name = name;
          this.amount = amount;
       }
       //存钱
       public  void deposit(float amt) {
          amount += amt;
          try {
             Thread.sleep(100);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
       }
       //取钱
       public  void withdraw(float amt) {
          amount -= amt;
          try {
             Thread.sleep(100);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
       }

       public float getBalance() {
          return amount;
       }
    }

    /**
     * 账户操作类
     */
    class AccountOperator implements Runnable{
       private Account account;
       public AccountOperator(Account account) {
          this.account = account;
       }

       public void run() {
          synchronized (account) {
             account.deposit(500);
             account.withdraw(500);
             System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
          }
       }
    }

    public class Synchronized_4 {
        public static void main(String[] args) {
            Account account = new Account("zhang san", 10000.0f);
            AccountOperator accountOperator = new AccountOperator(account);

            final int THREAD_NUM = 5;
            Thread threads[] = new Thread[THREAD_NUM];
            for (int i = 0; i < THREAD_NUM; i ++) {
               threads[i] = new Thread(accountOperator, "Thread" + i);
               threads[i].start();
            }
        }
    }
    结果为:
        Thread0:10000.0
        Thread4:10000.0
        Thread3:10000.0
        Thread2:10000.0
        Thread1:10000.0
    在AccountOperator 类中的run方法里,我们用synchronized 给account对象加了锁。这时,当一个线程访问
account对象时,其他试图访问account对象的线程将会阻塞,直到该线程访问account对象结束。也就是说谁拿到那个
锁谁就可以运行它所控制的那段代码。 当有一个明确的对象作为锁时,就可以用类似下面这样的方式写程序。
    public void method3(SomeObject obj){
        //obj 锁定的对象
        synchronized(obj)
        {
           // todo
        }
    }
当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的对象来充当锁:
    class Test implements Runnable {
        private byte[] lock = new byte[0];  // 特殊的instance变量
        public void method(){
           synchronized(lock) {
              // todo 同步代码块
           }
        }
        public void run() {

        }
    }
    说明:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:生成零长度的byte[]对象只需3条
操作码,而Object lock = new Object()则需要7行操作码。
    4、给方法加锁。示例如下:
        public synchronized void run() {
            for (int i = 0; i < 5; i ++) {
               try {
                  System.out.println(Thread.currentThread().getName() + ":" + (count++));
                  Thread.sleep(100);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
        }
    Synchronized作用于整个方法的写法。 
    写法一:
        public synchronized void method() {
              // todo
        }
    写法二:
        public void method() {
            synchronized(this) {
               // todo
            }
        }
    写法一修饰的是一个方法,写法二修饰的是一个代码块,但写法一与写法二是等价的,都是锁定了整个方法时的内容。
    在用synchronized修饰方法时要注意以下几点: 
    (1)synchronized关键字不能继承。 
    虽然可以使用synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此,synchronized关键字
不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认
情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然,还可以在子类方法中调用
父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步
了。这两种方式的例子代码如下: 
    在子类方法中加上synchronized关键字:
    class Parent {
         public synchronized void method() { }
    }
    class Child extends Parent {
         public synchronized void method() { }
    }
    在子类方法中调用父类的同步方法:
    class Parent {
         public synchronized void method() {   }
    }
    class Child extends Parent {
         public void method() { super.method();   }
    }
    (2)在定义接口方法时不能使用synchronized关键字。
    (3)构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。
    5、修饰一个静态的方法
    Synchronized也可修饰一个静态方法,用法如下:
    public synchronized static void method() {
       // todo
    }
    我们知道静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方法锁定的是这个类的所有对象。
    我们对Demo1进行一些修改如下:
    /**
     * 同步线程
     */
    class SyncThread implements Runnable {
       private static int count;

       public SyncThread() {
          count = 0;
       }

       public synchronized static void method() {
          for (int i = 0; i < 5; i ++) {
             try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(100);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
          }
       }

       public synchronized void run() {
          method();
       }
    }

    public class Synchronized_5 {
        public static void main(String[] args) {
            SyncThread syncThread1 = new SyncThread();
            SyncThread syncThread2 = new SyncThread();
            Thread thread1 = new Thread(syncThread1, "SyncThread1");
            Thread thread2 = new Thread(syncThread2, "SyncThread2");
            thread1.start();
            thread2.start();
        }
    }
    结果为:
        SyncThread1-0 
        SyncThread1-1 
        SyncThread1-2 
        SyncThread1-3 
        SyncThread1-4 
        SyncThread2-5 
        SyncThread2-6 
        SyncThread2-7 
        SyncThread2-8 
        SyncThread2-9
        syncThread1和syncThread2是SyncThread的两个对象,但在thread1和thread2并发执行时却保持了线程同
步。这是因为run中调用了静态方法method,而静态方法是属于类的,所以syncThread1和syncThread2相当于用了同一
把锁。这与Demo1是不同的。
    6、修饰一个类。示例如下:
    Synchronized还可作用于一个类,用法如下:
    class ClassName {
        public void method() {
            synchronized(ClassName.class) {
                // todo
            }
        }
    }
    再作一些修改:
/**
     * 同步线程
     */
    class SyncThread implements Runnable {
       private static int count;

       public SyncThread() {
          count = 0;
       }

       public static void method() {
          synchronized(SyncThread.class) {
             for (int i = 0; i < 5; i ++) {
                try {
                   System.out.println(Thread.currentThread().getName() + ":" + (count++));
                   Thread.sleep(100);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
             }
          }
       }

       public synchronized void run() {
          method();
       }
    }
    其效果和【Demo5】是一样的,synchronized作用于一个类T时,是给这个类T加锁,T的所有对象用的是同一把锁。

总结

A. 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;如果synchronized
作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。 
B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。 
C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。

多线程之synchronized关键字详解

synchronized关键字用于多线程访问程序中的共享资源时实现顺序同步访问资源。可以修饰方法或者代码块。而且关键字synchronized取得的锁都是对象锁,什么叫对象锁呢,就是一个对象产生一把锁...
  • Trigl
  • Trigl
  • 2016-04-15 20:23:17
  • 2852

java synchronized关键字,类锁,对象锁详解

在java编程中,经常需要用到同步,而用得最多的也许是synchronized关键字了,下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念,所以先来了解一些相关的锁知识。 ...
  • su_xiaocheng
  • su_xiaocheng
  • 2016-07-08 11:41:52
  • 1288

java中synchronized关键字的认识&记录

通过具体项目中在线程间同步遇到的问题(app无响应ANR)来阐述synchronized关键字的使用场景。...
  • bibingyan
  • bibingyan
  • 2017-02-21 20:27:57
  • 462

java的线程同步机制synchronized关键字的理解

  • 2011年10月25日 22:54
  • 85KB
  • 下载

java的关键字synchronized用法总结

第一篇:   使用synchronized   在编写一个类时,如果该类中的代码可能运行于多线程环境下,那么就要考虑同步的问题。在Java中内置了语言级的同步原语--synchronized,...
  • u010586698
  • u010586698
  • 2016-06-27 21:04:35
  • 1433

c#中volatile和synchronized

恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变 量修饰符,而synchronized则作用于一段代码或方法;看如下三句get代码: int ...
  • zwk_9
  • zwk_9
  • 2014-06-21 17:20:12
  • 2693

深入理解Java并发4——synchronized关键字

一 概述 由上一篇博客(http://blog.csdn.net/xiaowang627/article/details/60584428),我们已经体验到synchronized关键字的强大之处...
  • xiaowang627
  • xiaowang627
  • 2017-03-07 13:36:35
  • 333

关于java synchronized关键字的一些理解

看了java编程思想的并发这一章,发现对于synchronized关键字理解不够到位,看了其他人的博客,加深了一些理解:http://www.cnblogs.com/GnagWang/archive/...
  • yxl0011
  • yxl0011
  • 2016-12-20 16:05:33
  • 289

Java线程同步中关键字synchronized简述

Java线程同步中关键字synchronized简述 一、作用: synchronized关键字通过修饰一个方法或者声明一个代码块,从而产生一个同步对象锁以及对应的同步代码块。每当...
  • beiyus
  • beiyus
  • 2015-10-14 13:40:49
  • 2071

Java关键字系列 — volatile、synchronized、lock

volatile、synchronized和lock简单介绍
  • u011760575
  • u011760575
  • 2017-01-04 00:01:57
  • 524
收藏助手
不良信息举报
您举报文章:Java Synchronized关键字详解
举报原因:
原因补充:

(最多只允许输入30个字)