当前位置：移动技术网 > IT编程>开发语言>Java > Java多线程并发编程 Synchronized关键字

Java多线程并发编程 Synchronized关键字

2019年07月22日 | 移动技术网IT编程 | 我要评论

synchronized 关键字解析

同步锁依赖于对象，每个对象都有一个同步锁。

现有一成员变量 test，当线程 a 调用 test 的 synchronized 方法，线程 a 获得 test 的同步锁，同时，线程 b 也去调用 test 的 synchronized 方法，此时线程 b 无法获得 test 的同步锁，必须等待线程 a 释放 test 的同步锁才能获得从而执行对应方法的代码。

综上，正确使用 synchronized 关键字可确保原子性。

synchronized 关键字的特性应用

特性 1：

当线程 a 调用某对象的synchronized 方法或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的synchronized 方法或者 synchronized 代码块时将被阻塞，直至线程 a 释放该对象的同步锁。

demo1，synchronized 方法：

public class test {

  private static class counter {

    public synchronized void count() {
      for (int i = 0; i < 6; i++) {
        system.out.println(thread.currentthread().getname() + "， i = " + i);
      }
    }

  }

  private static class mythread extends thread {

    private counter mcounter;

    public mythread(counter counter) {
      mcounter = counter;
    }

    @override
    public void run() {
      super.run();
      mcounter.count();
    }
  }

  public static void main(string[] var0) {
    counter counter = new counter();
    // 注：mythread1 和 mythread2 是调用同一个对象 counter
    mythread mythread1 = new mythread(counter);
    mythread mythread2 = new mythread(counter);
    mythread1.start();
    mythread2.start();
  }

}

demo1 输出：

thread-0， i = 0
thread-0， i = 1
thread-0， i = 2
thread-0， i = 3
thread-0， i = 4
thread-0， i = 5
thread-1， i = 0
thread-1， i = 1
thread-1， i = 2
thread-1， i = 3
thread-1， i = 4
thread-1， i = 5

demo2，synchronized 代码块：

public class test {

  private static class counter {

    public void count() {
      synchronized (this) {
        for (int i = 0; i < 6; i++) {
          system.out.println(thread.currentthread().getname() + "， i = " + i);
        }
      }
    }
  }

  private static class mythread extends thread {

    private counter mcounter;

    public mythread(counter counter) {
      mcounter = counter;
    }

    @override
    public void run() {
      super.run();
      mcounter.count();
    }
  }

  public static void main(string[] var0) {
    counter counter = new counter();
    mythread mythread1 = new mythread(counter);
    mythread mythread2 = new mythread(counter);
    mythread1.start();
    mythread2.start();
  }
}

demo2 输出：

thread-0， i = 0
thread-0， i = 1
thread-0， i = 2
thread-0， i = 3
thread-0， i = 4
thread-0， i = 5
thread-1， i = 0
thread-1， i = 1
thread-1， i = 2
thread-1， i = 3
thread-1， i = 4
thread-1， i = 5

可见，当同步锁未释放时，其他线程将被阻塞，直至获得同步锁。

而且 demo1 和 demo2 的输出结果是一样的，synchronized 方法和 synchronized 代码块的不同之处在于 synchronized 方法作用域较大，作用于整个方法，而 synchronized 代码块可控制具体的作用域，更精准控制提高效率。（毕竟阻塞的都是时间啊）

demo3，仅修改 main 方法：

public static void main(string[] var0) {
    // 注意：mythread1 和 mythread2 传入的 counter 是两个不同的对象
    mythread mythread1 = new mythread(new counter());
    mythread mythread2 = new mythread(new counter());
    mythread1.start();
    mythread2.start();
  }

demo3 输出：

thread-0， i = 0
thread-1， i = 0
thread-0， i = 1
thread-1， i = 1
thread-1， i = 2
thread-1， i = 3
thread-0， i = 2
thread-1， i = 4
thread-0， i = 3
thread-1， i = 5
thread-0， i = 4
thread-0， i = 5

同步锁基于对象，只要锁的来源一致，即可达到同步的作用。所以，但对象不一样，则不能达到同步效果。

特性 2：

当线程 a 调用某对象的synchronized 方法或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的其他 synchronized 方法或者 synchronized 代码块时将被阻塞，直至线程 a 释放该对象的同步锁。（注意：重点是其他）

demo4，仅修改 dootherthings 方法的修饰：

public class test {

  private static class counter {

    public synchronized void count() {
      system.out.println(thread.currentthread().getname() + " sleep");
      try {
        thread.sleep(3000);
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
      system.out.println(thread.currentthread().getname() + " awake");
    }

    public synchronized void dootherthings(){
      system.out.println(thread.currentthread().getname() + " dootherthings");
    }
  }

  public static void main(string[] var0) {
    final counter counter = new counter();
    new thread(new runnable() {
      @override
      public void run() {
        counter.count();
      }
    }).start();
    new thread(new runnable() {
      @override
      public void run() {
        counter.dootherthings();
      }
    }).start();
  }
}

demo4 输出：

thread-0 sleep
thread-0 awake
thread-1 dootherthings

可见，synchronized 获得的同步锁并非仅仅锁住代码，而是锁住整个对象。

此时应提及 happens-before 原则，正因 happens-before 原则的存在才有此现象的发生。
happens-before 原则的其中一条：
管理锁定原则：一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
（此处暂不作过多解释，解释起来能再写一篇文章了）

demo5，仅修改 dootherthings 方法：

public void dootherthings(){
      synchronized (this){
        system.out.println(thread.currentthread().getname() + " dootherthings");
      }
    }

demo5 输出：

thread-0 sleep
thread-0 awake
thread-1 dootherthings

demo4 和 demo5 的输出结果竟然一致！没错，因为他们的同步锁来源一致（都是本实例自己），所以可以达到同步效果。

// 这两个 synchronized 锁的是同一个对象
public synchronized void count(){};
public void dootherthings(){
    synchronized (this){}
}

demo6，去掉 dootherthings 方法的同步关键字：

public void dootherthings(){
      system.out.println(thread.currentthread().getname() + " dootherthings");
    }

demo6 输出：

thread-0 sleep
thread-1 dootherthings
thread-0 awake

当线程 a 调用某对象的synchronized 方法或者 synchronized 代码块时，无论同步锁是否释放，其他线程调用同一对象的其他非 synchronized 方法或者非 synchronized 代码块时可立即调用。

实例锁和全局锁

以上 demo 实现的都是实例锁。锁住（作用域）的是具体某一对象实例。

什么是全局锁？
锁住整个 class，而非某个对象或实例。

注：单例型的实例锁不属于全局锁。

全局锁的实现：

静态 synchronized 方法

demo7：

public class test {

  private static class counter {

    public static synchronized void count() {
      system.out.println(thread.currentthread().getname() + " sleep");
      try {
        thread.sleep(3000);
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
      system.out.println(thread.currentthread().getname() + " awake");
    }

    public static synchronized void dootherthings(){
      system.out.println(thread.currentthread().getname() + " dootherthings");
    }
  }

  public static void main(string[] var0) {
    new thread(new runnable() {
      @override
      public void run() {
        counter.count();
      }
    }).start();
    new thread(new runnable() {
      @override
      public void run() {
        counter.dootherthings();
      }
    }).start();
  }
}

demo7 输出：

thread-0 sleep
thread-0 awake
thread-1 dootherthings

static 声明的方法为全局方法，与对象实例化无关，所以 static synchronized 方法为全局同步方法，与对象实例化无关。

synchronized 具体 class 的代码块

demo8：

public class test {

  private static class counter {

    public static synchronized void count() {
      system.out.println(thread.currentthread().getname() + " sleep");
      try {
        thread.sleep(3000);
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
      system.out.println(thread.currentthread().getname() + " awake");
    }

    public void dootherthings(){
      synchronized (counter.class){
        system.out.println(thread.currentthread().getname() + " dootherthings");
      }
    }
  }

  public static void main(string[] var0) {
    new thread(new runnable() {
      @override
      public void run() {
        counter.count();
      }
    }).start();
    new thread(new runnable() {
      @override
      public void run() {
        counter counter = new counter();
        counter.dootherthings();
      }
    }).start();
  }
}

demo8 输出：

thread-0 sleep
thread-0 awake
thread-1 dootherthings

synchronized (counter.class) 获得的同步锁是全局的，static synchronized 获得的同步锁也是全局的，同一个锁，所以达到同步效果。

区分 synchronized (this) 与 synchronized (class.class)

demo9：

public class test {

  private static class counter {

    public void count() {
      synchronized (this){
        system.out.println(thread.currentthread().getname() + " sleep");
        try {
          thread.sleep(3000);
        } catch (interruptedexception e) {
          e.printstacktrace();
        }
        system.out.println(thread.currentthread().getname() + " awake");
      }
    }

    public void dootherthings(){
      synchronized (counter.class){
        system.out.println(thread.currentthread().getname() + " dootherthings");
      }
    }
  }

  public static void main(string[] var0) {
    final counter counter = new counter();
    new thread(new runnable() {
      @override
      public void run() {
        counter.count();
      }
    }).start();
    new thread(new runnable() {
      @override
      public void run() {
        counter.dootherthings();
      }
    }).start();
  }
}

demo9 输出：

thread-0 sleep
thread-1 dootherthings
thread-0 awake

synchronized (this) 获得的是具体对象实例 counter 的锁，而 synchronized (counter.class) 获得的是全局锁，两把不同的锁，所以不能达到同步效果。

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

09.数据的条件查询操作

1. 条件查询WHERE筛选条件为true，则返回查询记录# 语法SELECT 查询列表 FROM 数据表名称 ... [阅读全文]
齐治堡垒机，功能诠释表！

堡垒机现如今走进很多企业或者是政府单位，在如今这个互联网的社会，也愈发让很多企业更加的重视安全，很多安全产品被广... [阅读全文]
SpringBoot引用阿里easyexcel，Excel导出返回浏览器下载

现在大的小的系统，各家的产品都差不多，一般运营或者产品规划的时候都会要求做一些导入导出数据的功能，他说供我统计或汇报用。好吧，我们苦逼的程序员开始干活了。 [阅读全文]
虚拟机下载apache2,解决虚拟机黑屏问题

这里写自定义目录标题虚拟机下载apache2虚拟机下载apache2更换代理在root下输入 wget... [阅读全文]
HashMap、Hashtable、ConcurrentHashMap三者间的异同

Hashtable 和 HashMap 的区别与联系1.两者都继承与map接口，所以两者的遍历方式大同小异2.H... [阅读全文]
等保测评--计算环境之终端设备安全

信息安全等级保护，是对信息和信息载体按照重要性等级分级别进行保护的一种工作，在中国、美国等很多国家都存在的一种信... [阅读全文]
解决RecycleView 中Item包含Edittext时，滑动view复用导致数据错乱的问题

解决RecycleView 中Item包含Edittext时，滑动导致数据错乱的问题一言不合就上代码：overr... [阅读全文]
[每日一练] Java 2020.7.28

1.关于以下application,说法正确是什么？public class Test { static ... [阅读全文]
学习多线程造成线程不同步的原因数组实现简单的栈三

java代码package com.baigu.demo1.stack;public class TestSta... [阅读全文]
多线程、同步工作原理、死锁案例、Lock接口、线程的生命周期的讲解及实现

多线程进程正在运行的程序，称为进程，一个应用程序在内存中占用的资源才是进程线程线程:是进程中的某-功能开启了一条... [阅读全文]

网友评论


验证码：

Java多线程并发编程 Synchronized关键字

2019年07月22日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论