Java synchronized 介绍

最新推荐文章于 2024-05-21 23:43:50 发布
最新推荐文章于 2024-05-21 23:43:50 发布
阅读量7.3k 收藏 7
点赞数 6
分类专栏： Java基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suifeng3051/article/details/48711405
版权

我们知道Java API提供了丰富的多线程机制，但是要想多线程机制能够正常运转，需要采取一些措施来防止多个线程访问相同的资源。为防止出现这样的冲突，只需在线程使用一个资源时为其加锁即可。访问资源的第一个线程加上锁以后，其他线程便不能再使用那个资源，除非被解锁。

而在java中，对这种特殊的资源—— 对象中的内存—— Java 提供了内建的机制来防止它们的冲突。用Java中的Synchronized关键字来标记一个方法或者一个代码块就可以实现资源的同步。

synchronized主要使用在多线程环境中，关于线程的相关介绍请参考【java线程详解】：http://blog.csdn.net/suifeng3051/article/details/49251959

一、Synchronized 关键字

在java中实现资源同步非常简单，只需要用synchronized关键字来标记即可。需要记住的是，在java中，同步加锁的是一个对象或者一个类，而不是代码。在多线程环境中，对象的所有synchronized方法一次只能被一个线程访问，其它所有访问同步块的线程会被一直阻塞直到同步块中的线程退出。

synchronized方法控制对类对象方法的访问，每个类对象都对应一把锁，每个 synchronized 方法都必须获得该方法所属对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该对象锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个对象实例，其所有声明为 synchronized 的实例函数中至多只有一个处于可执行状态，从而有效避免了类成员变量的访问冲突。注意，其它非synchronized的函数仍可被其它线程同时访问。

在 Java 中，不光是类的对象，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。

synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功，因此， Java 为我们提供了更好的解决办法，那就是 synchronized 代码块。

synchronized关键字可标记四种代码块：

1. 实例方法
2. 静态方法
3. 实例方法中的代码块
4. 静态方法中的代码块

二、同步实例方法

 public synchronized void add(int value){
  this.count += value;
 }

通过上面示例可以看出，同步实例方法很简单，在类的实例方法中添加synchronized关键字即可。需要注意，同步实例方法在java中同步加锁的其实是这个方法所属的对象，对于这个对象的同步方法，一次只能有一个线程访问。如果想让两个线程同时访问这个类的方法，那么为每个线程构造一个实例即可。因此，对于同步的实例方法，每个对象都会有自己的同步方法。在某个特定对象中，它的同步方法一次之能被一个线程访问，如果有多个对象，那么每个对象都可以允许一个线程访问自己的同步方法。下面我们通过两个例子来说明一下同步实例方法。

2.1 实例一：一个对象中的同步实例方法一次只允许一个线程访问

1.构造一个计数器类Counter ，这个计数器可能会被多个线程访问，需要对其中的add()方法进行同步

public class Counter {
  long count = 0;
  //同步实例方法
  public synchronized void add() {
         count++;
         try {
              Thread. sleep(100);
        } catch (InterruptedException e) {
               e.printStackTrace();
        }
        System. out.println(Thread. currentThread().getName() + "--" + count);
  }
}

2.构造计数器线程类CounterThread 来访问计数器对象的add()方法

public class CounterThread extends Thread {
  protected Counter counter = null;
  public CounterThread( Counter counter) {
         this. counter = counter;
  }
  public void run() {
         //用多个线程调用同步实例方法
         for ( int i = 0; i < 5; i++) {
               counter.add();
        }
  }
}

3.构造一个CounterExample，用两个线程来同时访问一个对象实例

public class CounterExample {
  public static void main(String[] args) {       
        //构造一个含同步方法的对象实例   
        Counter counter = new Counter();
        Thread threadA = new CounterThread( counter);
        Thread threadB = new CounterThread( counter);
         threadA.start();
         threadB.start();
  }
}

我们看一下运行结果：

Thread-0--1
Thread-1--2
Thread-0--3
Thread-1--4
Thread-1--5
Thread-0--6
Thread-1--7
Thread-1--8
Thread-0--9
Thread-0--10

通过运行结果可以看到，每次打印的结果都增加了1，说明同步的add()方法一次只有一个线程访问。

2.2 实例二：为每个线程构造一个实例对象，每个线程调用自己对象的同步实例方法

计数器类和计数器线程类不变，我们只改造CounterExample方法：

public class CounterExample {
  public static void main(String[] args) {
         //构造两个实例，让每个线程访问一个实例
        Counter counter1 = new Counter();
        Counter counter2 = new Counter();
        Thread threadA = new CounterThread( counter1);
        Thread threadB = new CounterThread( counter2);
         threadA.start();
         threadB.start();
  }
}

我们构造了两个对象，然后再构造两个线程，让每个线程访问一个对象的同步方法。此时，两个线程会同时访问各自对象的同步方法，我们来看一下运行结果：

Thread-0--1
Thread-1--1
Thread-0--2
Thread-1--2
Thread-0--3
Thread-1--3
Thread-0--4
Thread-1--4
Thread-0--5
Thread-1--5``

我们看到，每个线程打印出来的结果都是顺序加1，两个线程互不干扰。

三、同步静态方法

同步静态方法和同步实例方法的唯一区别就是同步静态方法把synchronized关键字加到了静态方法上，看下面例子：

public static synchronized void add(int value){
  count += value;
}

我们知道静态方法即类方法，它属于一个类而不是某个对象。因此同步静态方法同步的是类的方法，不是实例方法。所以即使是多个线程访问不同的对象的同步静态方法，它们之间每次也只能有一个线程访问。下面我们通过一个例子证明：

实例三：测试同步静态方法

我们把上面Counter类中的add()方法改为静态的，然后再加synchronized关键字

public class Counter {
  static long count = 0;
  //同步的是静态方法
  public static synchronized void add() {
         count++;
         try {
              Thread. sleep(100);
        } catch (InterruptedException e) {
               e.printStackTrace();
        }
        System. out.println(Thread. currentThread().getName() + "--" + count);
  }
}

然后同样用多个线程访问多个实例：

public class CounterExample {
  public static void main(String[] args) {
         //构造两个实例，让每个线程访问一个实例
        Counter counter1 = new Counter();
        Counter counter2 = new Counter();
        Thread threadA = new CounterThread( counter1);
        Thread threadB = new CounterThread( counter2);
         threadA.start();
         threadB.start();
  }
}

我们看一下运行结果：

Thread-0--1
Thread-0--2
Thread-0--3
Thread-1--4
Thread-1--5
Thread-1--6
Thread-0--7
Thread-0--8
Thread-1--9
Thread-1--10``

我们可以看到，两个线程打印的结果都是连续加1的，add()方法是被同步访问的。

如果我们去掉上面add()方法中的synchronized关键字，大家猜一下结果又会是如何呢？我们看一下实验结果：

Thread-0--2
Thread-1--2
Thread-1--4
Thread-0--4
Thread-0--6
Thread-1--6
Thread-1--8
Thread-0--9
Thread-0--10
Thread-1--10

可以看到，两个线程每次打印结果都增加了2（线程的调度是不确定的，实际中的打印值有可能不同），因为，add()方法没有加同步关键字，所以add()方法同时被两个线程访问，所以每个线程打印出来结果都增加了2。

四、同步实例方法中的代码块

我们不必每次同步整个方法，有些时候我们希望仅仅是同步方法中的某个代码块。同步代码块主要有三种方式 :synchronized(this)、synchronized (obj)、synchronized(Object.class)(这种方法在同步静态代码块中会讲到)，这三种方式分别是指同步本对象、同步其它对象、同步某个类。下面我们先分别举例说明前两种情况

3.1 实例四：同步代码块之synchronized(this)

我们把实例一Counter类 add()方法声明中的synchronized关键字加到add()代码块中，其它类不变：

public class Counter {
long count = 0;
public void add() {
    //同步代码块
    synchronized(this){
        count++;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "--" + count);
    }

}
}

上面这个例子就是通同步代码块的方式同步代码，运行结果应该和实例一的一致。

请注意，同步代码块中有一个构造参数，这个参数值是一个对象，被称作监控对象，意思是同步的是此监控对象中的同步方法。上面这个例子中，（this）指的本对象。

下面我们再举个参数是一个其它对象的例子。

3.2 实例五：同步代码块之synchronized(obj)

我们先构造一个普通的Counter类

public class Counter {
  long count = 0;
  public void add() {
         count++;
         try {
              Thread. sleep(100);
        } catch (InterruptedException e) {
               e.printStackTrace();
        }
        System. out.println(Thread. currentThread().getName() + "--" + count);
  }
}

接下来再构造一个含同步代码块的CountSynBlock类，在这个类的add方法中，synchronized 构造参数中是Counter类的一个实例变量

public class CounterSynBlock {
  //声明一个实例变量
  private Counter counter;
  CounterSynBlock(Counter counter){
         this. counter= counter;
  }
  public void add() {
         //同步的是Counter对象实例
         synchronized ( counter) {
               counter.add();
        }
  }
}

我们再运行一个CounterExample

public class CounterExample {
  public static void main(String[] args) {
         //构造两个实例，让每个线程访问一个实例
        Counter counter= new Counter();
        CounterSynBlock counterSynBlock1 = new CounterSynBlock( counter);
        CounterSynBlock counterSynBlock2 = new CounterSynBlock(counter);
        Thread threadA = new CounterThread( counterSynBlock1);
        Thread threadB = new CounterThread( counterSynBlock2);
         threadA.start();
         threadB.start();
  }

大家看，在这个CounterExample中，我们分别实例化了2个CounterSynBlock实例，然后用两个线程分别访问这两个实例的同步代码块，但这两个实例中的同步的不是CounterSynBlock 对象，而是counter对象，所以，counter中的add()方法应该是被同步访问的。

看一下运行结果：

Thread-0--1
Thread-0--2
Thread-0--3
Thread-1--4
Thread-0--5
Thread-0--6
Thread-1--7
Thread-1--8
Thread-1--9
Thread-1--10

如果我们把CounterSynBlock类add()方法中的synchronized ( counter)换成synchronized(this)，则同步的就成了CounterSynBlock的add()方法了，那么两个线程则会分别访问自己的同步方法，我们举例验证一下：

1.首先把CounterSynBlock类中的同步代码块synchronized ( counter)改回synchronized(this)

public class CounterSynBlock {
  //声明一个实例变量
  private Counter counter;
  CounterSynBlock(Counter counter){
         this. counter= counter;
  }
  public void add() {
         //同步的是本对象
         synchronized ( this) {
               counter.add();
        }
  }
}

2.我们再运行一下CounterExample

public class CounterExample {
  public static void main(String[] args) {
         //构造两个实例，让每个线程访问一个实例
        Counter counter= new Counter();
        CounterSynBlock counterSynBlock1 = new CounterSynBlock( counter);
        CounterSynBlock counterSynBlock2 = new CounterSynBlock(counter);
        Thread threadA = new CounterThread( counterSynBlock1);
        Thread threadB = new CounterThread( counterSynBlock2);
         threadA.start();
         threadB.start();
  }

3.看一下结果：

Thread-1--2
Thread-0--2
Thread-1--4
Thread-0--5
Thread-1--6
Thread-0--7
Thread-1--8
Thread-0--9
Thread-1--10
Thread-0--10

从结果可以看到，当把同步的对象由counter改为this后，打印的结果并不是连续的加1，说明两个线程产生了并发访问counter的同步方法情况。

五、同步静态方法代码块

上面讲到，除了在代码块中使用synchronized(this)、synchronized(obj)之外，还可以使用synchronized(Object.class)同步一个类，既然这个类被同步了，那么多线程对所有的类变量访问也该是同步的，下面我们就举例说明。

实例六：同步静态代码块之synchronized(Object.class)

首先，构造一个Counter类，在这个类中，同步的是类本身

public class Counter {
//注意，此处的变量是静态的，属于类变量
static long count = 0;
public  void add() {
    //同步的是这个类本身
    synchronized(Counter.class){
        count++;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            System.out.println(Thread.currentThread().getName() + "--" + count);
    }
}
}

其次，构造一个线程对象CounterThread ，访问Counter的同步代码块，代码块中同步的是Counter类本身

   public class CounterThread extends Thread {
protected Counter counter = null;
public CounterThread(Counter counter) {
    this.counter = counter;
}
public void run() {
    //用多个线程调用同步实例方法
    for (int i = 0; i < 5; i++) {
        counter.add();
    }
}
}

最后，运行下面这个测试类

public class CounterExample {
public static void main(String[] args) {
    //构造两个实例，让每个线程访问一个实例
    Counter counter1=new Counter();
    Counter counter2=new Counter();
    CounterThread threadA = new CounterThread(counter1);
    CounterThread threadB = new CounterThread(counter2);
    threadA.start();
    threadB.start();
}
}

我们看一下运行结果：

Thread-0--1
Thread-0--2
Thread-0--3
Thread-1--4
Thread-0--5
Thread-1--6
Thread-0--7
Thread-1--8
Thread-1--9
Thread-1--10

虽然每个线程访问的是各自的对象，由于Counter类中的count变量是static的，所以count是类的变量，因为我们同步的是Counter类本身，而不是它的实例，因此多线程对类变量的访问是同步的。

六、总结

最后做一下总结

  1. 在多线程环境中，可以使用synchronized关键字对资源进行同步
  2. synchronized关键字可以同步方法和代码块
  3. 同步的是对象或者类，而不是代码
  4. 一个对象中的同步方法一次只能被一个线程访问，如果有多个同步方法，一个线程一次也只能访问其中的一个同步方法，但是非同步方法不受任何影响
  5. 同步是通过加锁的形式来控制的，让一个线程访问一个同步方法时会获得这个对象的锁，只有退出同步方法时才会释放这个锁，其它线程才可访问
Heaven-Wang
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java 对方法的参数加锁_个人对synchronized锁的参数理解，如果有误望指出
weixin_32301557的博客
02-16 1789
该楼层疑似违规已被系统折叠隐藏此楼查看此楼synchronized有几种用法给方法加锁也就是在声明方法时加上synchronized关键字，这样同时就只能有一个线程访问该方法其次就是代码块，synchronized(xx){xxx}但是之前我一直不解括号里面的参数是什么..后来自己慢慢翻资料理解了一些，例如synchronized(this){xxx} this我们都知道是指当前方法的所属类而s...
对synchronized(参数)里参数即同步监视器的理解
java1592724884的博客
04-04 969
在学习java线程同步的时候,总感觉同步监视器是多余的，因为既然已经用synchronize对代码块进行了锁定，那么传的参数还有什么意义？ 首先，在语法上，该参数可为任意对象。 但是在实际项目中必须慎重选取同步监视器，我认为同步监视器实质上应该是“放锁的位置”。 1、对代码区域进行synchronize（同步监视器）处理后，所有进入该代码块区域的线程必须去“看看”同步监视器上有没有“放置”锁，如果...
javaAPI文档中文版（JDK11在线版）java帮助文档，掌握文档java学习事半功倍。
最新发布
2301_76710832的博客
05-21 538
菜鸟教程提供Java API文档中文版，涵盖了Java开发所需的各种类和方法的说明。该文档以JDK 11为基础，包括Java核心库中的各个模块。通过目录或搜索功能可快速找到所需内容，并查看其用法、参数、返回值等信息。菜鸟教程还提供Java教程和示例代码，帮助初学者更好理解、应用Java编程语言。Java API文档是一个方便的参考工具，适用于Java初学者和有经验的开发者，可帮助更高效地开发Java应用程序。
CUDA编程 cudaDeviceSynchronize()返回值700的意思
benobug的博客
03-30 4491
经过几番折腾，终于搞清了cudaDeviceSynchronize()函数同时时出错，返回值为700的原因：向在设备上执行的函数传递了只能在主机上使用的指针 任何传到核函数（在设备——也就是GPU——上执行的函数）的参数都需要通过cudaMalloc()来分配内存，该函数的作用是告诉CUDA运行时在设备上分配内存。原型为 cudaMalloc((void**)ptr, size_t len); ...
synchronized 用法详解
u010349644的专栏
06-13 237
1、简介 在Java中，提供了一个关键字 synchronized 来保证多线程安全问题，synchronized可以修饰一个方法、代码块，能够保证在同一时刻最多只有一个线程执行该段代码。本篇文章将全面讲解synchronized 各种情景下的使用及产生的作用。 2、synchronized 修饰某一非静态方法 我们先看一下示例： private class MyObject1{ public synchronized void method1(String name){
Java 基础 —— synchronized 关键字详解
IT__learning的博客
11-03 1817
一、synchronized 三大特性 在多线程的环境下，多个线程同时访问共享资源会出现一些问题，而 synchronized 关键字则是用来保证线程同步的。 synchronized 关键字可以保证并发编程的三大特性：原子性、可见性、有序性。而 volatile关键字只能保证可见性和有序性，不能保证原子性，也称为是轻量级的 synchronized。 （1）原子性：一个或多个操作要么全部执行成功，要么全部执行失败。synchronized 关键字可以保证只有一个线程拿到锁，访问共享资源。 （2）可见性：
Java中synchronized正确使用方法解析
08-25
本文将详细介绍 Java 中 synchronized 的正确使用方法，通过示例代码和实践案例，帮助读者深入理解 synchronized 的使用方法和原理。 一、并行和锁 并行是一种提高程序效率的方式，它允许多个线程同时执行，提高...
java synchronized demo
04-19
测试java中synchronized到底锁住了什么，完整demo
java synchronized关键字的用法
09-02
0; public synchronized void...综上所述，synchronized 关键字是 Java 中实现线程同步的重要手段，它通过加锁机制保证了线程安全。然而，在实际应用中，我们需要根据具体场景选择合适的同步策略，以兼顾性能和正确性。
Java synchronized关键字使用方式及特性解析
08-25
Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法...
Java Synchronized的使用详解
08-18
Java Synchronized的使用详解 Java Synchronized是Java编程语言中的一种同步机制，用于解决并发编程中的线程安全问题。下面是对Java Synchronized的使用详解的知识点总结： 1. 为什么要使用Synchronized？ 在并发...
synchronized详解
12-24
synchronized详解，很详细。
synchronized 参数的理解
weixin_30597269的博客
11-07 628
synchronized 是java中用来同步的方法，详细的就不介绍了。 synchronized的用法为： synchronized(锁){ 代码块 } 这个锁是什么呢，我看了很多说法但没有一个能讲清楚的。 通过一段时间的使用后逐渐发现了一些synchronized使用的规律 使用synchronized是为了防止多个线程同时处理同一个方法，例如在同一时间使用push方法。 问题在于锁使用的范围...
synchronized () 括号中应该传什么对象？
dubbo
01-12 1万+
我看jdk源码的时候发现了这样的代码 同步锁中传入了静态的自定义的类“Lock” 1、这种写法和直接传this有什么区别？ 2、类“Lock”定义成静态和不定义成静态有什么区别？ 对于代码块同步，也就是synchronized(lock){} 这样的写法，lock这个对象就是 “锁”,当两个并行的线程a,b,当a先进入同步块，即a先拿到lock对象，这时候a就相当于用一把锁把synchroniz...
synchronized对于加锁代码块、方法以及全局(static)锁的详细对比
热门推荐
linlvting1314的博客
02-22 1万+
在网上看了许多关于synchronized的介绍及用法区别，大多大同小异，点到为止，个人推荐一篇博友写的，网址如下：http://blog.csdn.net/cs408/article/details/48930803这篇博客是介绍对象锁和类锁的区别，通俗易懂，而我的这篇博客是基于此基础上引申出，用实际的代码分析对象和类在方法、代码段加锁及静态时的对比。开始先普及一下java里synchroniz...
Java中synchronized关键字锁定的内容
imzoer的专栏
10-09 1万+
synchronized关键字能锁定什么？通常我们锁定的是一个对象或者是一个代码块。其实synchronized还能锁定一些其他内容。       同步分为 同步方法 和 同步块 两种方式。       变量分为 实例变量(不带static的变量) 和 类变量(带static的变量)。       同步锁锁定的内容是什么?       无论你将Synchronized加在方法【非stati
java中synchronized关键字的认识&记录
Jarry's World
02-21 9983
通过具体项目中在线程间同步遇到的问题（app无响应ANR）来阐述synchronized关键字的使用场景。
Synchronized全面介绍
qq_40729302的博客
04-16 1478
Synchronized 并发编程的三个重要特性： 原子性：一个操作或者多次操作，要么所有操作全部得到执行，并且不会受到任何因素的干扰而中断，要么所有的操作都执行，要么都不执行。 可见性：当一个线程对共享变量进行修改，另外的线程可以立即得到修改后的最新的值。 有序性：程序在多线程下，程序中代码执行的顺序是代码的先后执行的。程序代码不会因为指令重排序（程序为了优化执行效率从而打乱了代码的执行顺序）而打乱，从而导致程序产生不同的结果。 synchronized可以保证原子性，有序性和可见性 另一个关键字v
Java synchronized
09-14
Java中的synchronized关键字用于实现线程同步，确保多个线程对共享资源的访问顺序和安全性。当某个方法或代码块被synchronized修饰时，同一时间只能有一个线程执行该方法或代码块，其他线程需要等待。 synchronized关键字可以用于两种方式： 1. 同步方法：在方法声明中使用synchronized关键字，将整个方法体作为临界区，确保同一时间只能有一个线程进入该方法执行。 例如： ```java public synchronized void method() { // 方法体 } ``` 2. 同步代码块：使用synchronized关键字包裹需要进行同步的代码块，以确保只有一个线程可以进入临界区执行。 例如： ```java public void method() { synchronized (obj) { // 需要同步的代码块 } } ``` 这里的obj可以是任意对象，用于指定锁定的对象。 当多个线程试图同时访问同一个被synchronized修饰的方法或代码块时，只有一个线程可以执行，其他线程需要等待，直到占用该资源的线程释放锁。这样可以避免多个线程同时修改共享资源导致的数据不一致或冲突问题。 需要注意的是，synchronized关键字仅仅保证了临界区的互斥性，并不能保证线程的执行顺序。如果需要保证某种顺序，需要额外的逻辑或其他同步工具的配合使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值