Java synchronized 介绍

最新推荐文章于 2023-06-07 16:10:43 发布
最新推荐文章于 2023-06-07 16:10:43 发布
阅读量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
关注
专栏目录
Synchronized简单介绍(原理、使用、对比分析)
haovin的博客
06-04 389
0、目录 一、介绍 二、原理 三、具体使用 四、总结 一、介绍 二、原理 Synchronized在JVM中实现的原理。每一个对象都有一个监视器锁（monitor），JVM通过进入或退出monitor对象来实现方法同步和代码块同步。monitorenter指令是同步开始的位置，monitorexit是同步结束的位置，两者成对出现。 monitorenter: 线程执行moni...
synchronized的介绍
u011521890的专栏
09-12 511
我对synchronized关键字算是很熟悉的了，但是有些时候一些概念还是没有搞明白，今天通过对wiki翻译以及博客的学习，从概念和类别上对其进行区分，并整理了一套自己的理解方式。 从类别来区分 从类别上可以将锁分为类级别锁和对象级别锁 1. 类级别锁，作用于整个类的的同步锁，例如Object.class 2. 对象级别锁，new Object()产生的锁，不同的实例所持有的锁是不同的
synchronized简介
qq_40354931的博客
06-22 196
synchronized 并发编程是Java程序员最重要的技能之一，也是最难掌握的一种技能。它要求编程者对计算机最底层的运作原理有深刻的理解，同时要求编程者逻辑清晰、思维缜密，这样才能写出高效、安全、可靠的多线程并发程序。本系列会从线程间协调的方式（wait、notify、notifyAll）、Synchronized及Volatile的本质入手，详细解释JDK为我们提供的每种并发工具和底层实现机制。在此基础上，我们会进一步分析java.util.concurrent包的工具类，包括其使用方式、实现源码及其
synchronized详解
m0_55889841的博客
06-12 156
synchronized详解
Java中synchronized正确使用方法解析
08-25
本文将详细介绍 Java 中 synchronized 的正确使用方法，通过示例代码和实践案例，帮助读者深入理解 synchronized 的使用方法和原理。 一、并行和锁 并行是一种提高程序效率的方式，它允许多个线程同时执行，提高...
Java synchronized关键字使用方式及特性解析
08-25
Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法...
Java synchronized详细解读.docx
06-21
Java中的`synchronized`关键字是多线程编程中用于同步控制的关键元素，它的主要目标是解决并发环境下多个线程对共享资源的访问冲突。在Java中，由于线程共享内存空间，如果没有适当的同步机制，可能会导致数据不一致...
java synchronized demo
04-19
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它用于实现线程同步，以确保多线程环境下的数据一致性与安全性。本示例"java synchronized demo"旨在探讨`synchronized`关键字的用法及其作用机制。...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
在Java编程语言中，synchronized关键字用于实现线程同步，以确保多线程环境下的数据一致性。它主要用于控制对共享资源的并发访问，防止多个线程同时进入临界区，可能导致数据不一致或竞态条件的问题。本文将深入探讨...
synchronized简单理解
最新发布
qq_36138652的博客
06-07 1015
synchronized
java synchronized 参数_Java多线程的~~~synchronized加入参数，以实现独立片段
weixin_35827472的博客
02-16 228
有时候，我们不希望在整个方法的前面加上synchronized这个keyword。这将使整个方法调用变得缓慢，我们只是重点代码的地方添加这个synchronized这个keyword，然后这样就能加快方法或者代码的运行效率。然后可能另一种情况就是，我们有两个变量，当中不论什么一个变量都是同一时候仅仅能一个变量訪问，可是两个变量能够在同一时候被两个变量訪问。这样的需求下我们就得使用sychroniz...
Java synchronized参数的讨论
YanzheShi的专栏
11-22 5743
/** * synchronize关键字参数测试类 * synchronized关键字参数必须是多个线程共享的变量,才能达到同步目的 * 例如: * 1. 如果用了类里面的一个属性object作为锁,由于这个属性 * 每一个实例化对象都有一份,所以运行发现3个线程都没有同步 * 2. 如果用了类对象的class对象或者是类的静态属性作为锁, * 由于这个对象是类共享的,所以同一个My
java synchronized 参数_synchronized 参数的理解
weixin_34652034的博客
02-24 1252
synchronized 是java中用来同步的方法，详细的就不介绍了。synchronized的用法为：synchronized(锁){代码块}这个锁是什么呢，我看了很多说法但没有一个能讲清楚的。通过一段时间的使用后逐渐发现了一些synchronized使用的规律使用synchronized是为了防止多个线程同时处理同一个方法，例如在同一时间使用push方法。问题在于锁使用的范围，其实这个我也不...
Java synchronized
a85809291的博客
04-13 1万+
使用原则synchronized用于同步代码块，被同步的代码块将会条件性的限制线程对其的访问(限制条件取决于synchronized之后紧跟括号内的参数对象)。synchronized可直接修饰方法，也可修饰于代码块。 修饰代码块public void a() { synchronized(o) { }//代码块中包含需要同步的内容 }此种使用方法中，synchronized后括号中传入一个对象
java synchronized用法
热门推荐
黑山老腰
09-04 1万+
总结一下synchronized的用法： 1、修饰静态方法 2、修饰实例方法 3、修饰代码块 一、首先看一下修饰静态方法和修饰实例方法的区别，直接上代码： /* * synchronized：修饰实例方法/修饰静态方法 */ public class SynchronizedTest2 { public static void main(String[] args) thr...
Java 基础 —— synchronized 关键字详解
IT__learning的博客
11-03 1981
一、synchronized 三大特性 在多线程的环境下，多个线程同时访问共享资源会出现一些问题，而 synchronized 关键字则是用来保证线程同步的。 synchronized 关键字可以保证并发编程的三大特性：原子性、可见性、有序性。而 volatile关键字只能保证可见性和有序性，不能保证原子性，也称为是轻量级的 synchronized。 （1）原子性：一个或多个操作要么全部执行成功，要么全部执行失败。synchronized 关键字可以保证只有一个线程拿到锁，访问共享资源。 （2）可见性：
synchronized 参数 及其含义
知我饭否
11-14 1万+
这个想必大家都不陌生，java里面的重量级锁。用来控制线程安全的。在long And long ，我刚开始接触java的时候 ，我就对这个关键词好奇颇深。尤其是 它的参数，有this的 也有静态变量的。网上对这个参数解释又太过术语话。 例如： 作用于方法时，锁住的是对象的实例(this)； 当作用于静态方法时，锁住的是Class实例，又因为Class的相关数据存储在永久带PermGen（jd...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值