Java关键字 -- synchronized

最新推荐文章于 2024-09-07 14:57:30 发布
最新推荐文章于 2024-09-07 14:57:30 发布
阅读量10w+ 收藏 91
点赞数 14
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amosstan/article/details/120161969
版权
本文详细介绍了Java中的synchronized关键字，包括其用于代码块、方法和静态方法的用法，以及同步的作用和原理。通过示例展示了synchronized如何保证线程安全，防止数据竞争，并探讨了其对性能的影响和注意事项。
摘要由CSDN通过智能技术生成

一、介绍

synchronized是Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。

当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍可以访问该object中的非加锁代码块。

二、用法

synchronized修饰的对象有以下几种：

  1. 修饰代码块
  2. 修饰方法
  3. 修饰静态方法
  4. 修饰类

三、用法

3.1 修饰代码块

被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。

3.2.1 情况一

一个线程访问一个对象中的synchronized(this)同步代码块时，其它试图访问该对象的线程将被阻塞。

package com.test.sync1;

public class Sync1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("synchronized 修饰代码块");
		
		SyncThread st = new SyncThread();
		Thread th1 = new Thread(st, "线程1");
		Thread th2 = new Thread(st, "线程2");
		
		th1.start();
		th2.start();
	}

}

class SyncThread implements Runnable {
	
	private static int count = 0;
	
	public SyncThread() {
		// TODO Auto-generated constructor stub
		count = 0;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		/**
		 * 修饰一个代码块
		 * 被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。
		 * */
		synchronized (this) {
			for (int i = 0; i < 5; i++) {
				try {
					System.out.println("线程名: " + Thread.currentThread().getName() + ":" + (count++));
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
}

运行结果如下：

synchronized 修饰代码块
线程名: 线程1:0
线程名: 线程1:1
线程名: 线程1:2
线程名: 线程1:3
线程名: 线程1:4
线程名: 线程2:5
线程名: 线程2:6
线程名: 线程2:7
线程名: 线程2:8
线程名: 线程2:9

不使用synchronized关键字运行结果：

	@Override
	public void run() {
		// TODO Auto-generated method stub
		/**
		 * 修饰一个代码块
		 * 被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。
		 * */
		//synchronized (this) {
			for (int i = 0; i < 5; i++) {
				try {
					System.out.println("线程名: " + Thread.currentThread().getName() + ":" + (count++));
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		//}
	}

打印如下：

synchronized 修饰代码块
线程名: 线程1:1
线程名: 线程2:0
线程名: 线程1:2
线程名: 线程2:3
线程名: 线程1:4
线程名: 线程2:5
线程名: 线程1:6
线程名: 线程2:7
线程名: 线程1:8
线程名: 线程2:9

当两个并发线程(th1和th2)访问同一个对象(st)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。

th1和th2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

我们再稍微改一下main函数中的new Thread()，代码如下：

public class Sync1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("synchronized 修饰代码块");
		
		SyncThread st = new SyncThread();
		//Thread th1 = new Thread(st, "线程1");
		//Thread th2 = new Thread(st, "线程2");
		Thread th1 = new Thread(new SyncThread(), "线程1");
		Thread th2 = new Thread(new SyncThread(), "线程2");
		
		th1.start();
		th2.start();
	}

}

运行结果如下：

synchronized 修饰代码块
线程名: 线程1:1
线程名: 线程2:0
线程名: 线程1:2
线程名: 线程2:3
线程名: 线程1:4
线程名: 线程2:5
线程名: 线程1:6
线程名: 线程2:7
线程名: 线程2:9
线程名: 线程1:8

为什么上面的例子中th1和th2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联，而上面的代码等同于下面这段代码：

public class Sync1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("synchronized 修饰代码块");
		
		SyncThread st1 = new SyncThread();
		SyncThread st2 = new SyncThread();
		//Thread th1 = new Thread(st, "线程1");
		//Thread th2 = new Thread(st, "线程2");
		Thread th1 = new Thread(st1, "线程1");
		Thread th2 = new Thread(st2, "线程2");
		
		th1.start();
		th2.start();
	}

}

这时创建了两个SyncThread的对象st1和st2，线程th1执行的是st1对象中的synchronized代码(run)，而线程th2执行的是st2对象中的synchronized代码(run)；我们知道synchronized锁定的是对象，这时会有两把锁分别锁定st1对象和st2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

3.2.2 情况二

当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。

代码如下：

package com.test.sync1;

public class Sync1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("synchronized 修饰代码块");
		
		SyncThread st = new SyncThread();

		Thread th1 = new Thread(st, "线程1");
		Thread th2 = new Thread(st, "线程2");
		
		th1.start();
		th2.start();
	}

}

class SyncThread implements Runnable {
	
	private static int count = 0;
	
	public SyncThread() {
		// TODO Auto-generated constructor stub
		count = 0;
	}
	
	public void add() {
		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();
            }
        }
    }
	@Override
	public void run() {
		// TODO Auto-generated method stub
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("线程1")) {
            add();
        } else if (threadName.equals("线程2")) {
            printCount();
        } 
	}
	
}

运行结果：

synchronized 修饰代码块
线程1:0
线程2 count:0
线程1:1
线程2 count:2
线程1:2
线程2 count:3
线程1:3
线程2 count:4
线程1:4
线程2 count:5

上面代码中add是一个synchronized的，printCount是非synchronized的。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

3.2 修饰方法

被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。

synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。

如将的run方法改成如下的方式，实现的效果一样:

	@Override
	public synchronized void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 5; i++) {
			try {
				System.out.println("线程名: " + Thread.currentThread().getName() + ":" + (count++));
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

synchronized作用于整个方法的写法：

// 写法一
public synchronized void method()
{
   // todo
}

// 写法二
public void method()
{
   synchronized(this) {
      
   }
}

写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。

在用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();   }
}

  1. 在定义接口方法时不能使用synchronized关键字。

  2. 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步

3.3 修饰静态方法

其作用的范围是整个静态方法，作用的对象是这个类的所有对象。

用法如下：

public synchronized static void method() {
   
}

我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

package com.test.sync1;

public class Sync1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("synchronized 修饰静态方法");
		
		SyncThread st1 = new SyncThread();
		SyncThread st2 = new SyncThread();

		Thread th1 = new Thread(st1, "线程1");
		Thread th2 = new Thread(st2, "线程2");
		
		th1.start();
		th2.start();
	}

}

class SyncThread implements Runnable {
	
	private static int count = 0;
	
	public SyncThread() {
		// TODO Auto-generated constructor stub
		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();
            }
        }
    }
    
	@Override
	public void run() {
		// TODO Auto-generated method stub
		method();
	}
	
}


synchronized 修饰静态法
线程1:0
线程1:1
线程1:2
线程1:3
线程1:4
线程2:5
线程2:6
线程2:7
线程2:8
线程2:9

st1和st2是SyncThread的两个对象，但在th1和th2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以st1和st2相当于用了同一把锁。这与使用关键字synchronized运行结果相同。

3.4 修饰类

其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

package com.test.sync1;

public class Sync1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("synchronized 修饰类");
		
		SyncThread st1 = new SyncThread();
		SyncThread st2 = new SyncThread();

		Thread th1 = new Thread(st1, "线程1");
		Thread th2 = new Thread(st2, "线程2");
		
		th1.start();
		th2.start();
	}

}

class SyncThread implements Runnable {
	
	private static int count = 0;
	
	public SyncThread() {
		// TODO Auto-generated constructor stub
		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();
                }
            }			
		}
    }
    
	@Override
	public synchronized void run() {
		// TODO Auto-generated method stub
		method();
	}
	
}

运行结果：

synchronized 修饰类
线程1:0
线程1:1
线程1:2
线程1:3
线程1:4
线程2:5
线程2:6
线程2:7
线程2:8
线程2:9

效果和上面synchronized修饰静态方法是一样的，synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁。

四、总结

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

五、参考信息

Java中Synchronized的用法（简单介绍）
深入浅出synchronized

Amosstan
关注
专栏目录
【java】java 关键字: synchronized详解
九师兄
12-21 7159
关键字: synchronized详解【Java】Synchronized 有几种用法【java】 从hotspot底层对象结构理解锁膨胀升级过程【java】动态高并发时为什么推荐重入锁而不是Synchronized？请带着这些问题继续后文，会很大程度上帮助你更好的理解synchronized。Synchronized可以作用在哪里?分别通过对象锁和类锁进行举例。Synchronized本质上是通过什么保证线程安全的?分三个方面回答：加锁和释放锁的原理，可重入原理，保证可见性原理。
《volatile使用与学习总结：2023-12-17》多层面分析学习java关键字--volatile
weixin_44976692的博客
12-18 6万+
volatile是java中提供的一种轻量级的同步机制，相比于synchronized更加轻量，因为volatile避免了线程频繁的上下文切换和调度，但是也有缺点，同步性差并且使用起来易出错。
java之sync与lock的区别？
fycghy0803的专栏
05-05 2961
1.sync是一个关键字,lock是一个接口; 2.sync可以锁代码块，也可以锁方法,而lock只能锁代码块; 3.lock提供的有trylock方法，通过trylock可以中断锁; 4.lock提供有读写锁，读读不互斥,从而提高了读的效率，读写，写写互斥； 5.sync是非公平锁，而lock支持公平锁和非公平锁; 6.sync不需要手动释放锁，而lock需要手工释放锁; ...
synchronized
最新发布
m0_74064008的博客
09-07 818
变量的值会被加载到线程的工作内存中，但此时还未赋值到线程工作内存的副本中。偏向锁使得一个线程对一个对象的锁有偏向，默认情况下，锁会偏向于第一个获取它的线程。并发编程时，当一个线程对共享变量操作一半时，另外的线程也可能开始对共享变量进行操作，从而干扰前一个线程的操作。将读取到的变量值从线程的工作内存赋值给工作内存的变量副本中。依然会发生重排序，但有同步代码块，可以保证一个线程执行同步代码块中的代码，保证有序性。是Java中一种基本的同步机制，通过锁的升级过程和一系列的优化手段，可以适应不同的并发场景。
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
Java中的synchronized关键字
林隐的博客
11-30 1273
Java中的synchronized关键字
java中synchronized关键字
龙空白白的博客
06-10 4070
synchronized是java中的一个关键字，在中文中为同步，也被称之为’同步锁’,以此来达到多线程并发访问时候的并发安全问题，可以用来修饰代码块、非静态方法。静态方法等； 修饰代码块时:给当前指定的对象加锁 修饰非静态方法时:作用于当前实例加锁 修饰静态方法时:作用于当前类对象加锁 synchronized在java内存模型中的主要作用 原子性:通过monitorenter和monitorexit指令,保证被synchronized修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程
Java关键字——synchronized
qq_35854212的博客
02-16 749
synchronized使用和原理全解
Java 多线程与并发(4-26)-关键字- synchronized详解.pdf
07-21
"Java 多线程与并发(4-26)-关键字- synchronized详解" Java 多线程与并发中的 synchronized 关键字是实现同步块的互斥访问和线程的阻塞及唤醒等工作的重要工具。下面将对 synchronized 关键字进行详细分析。 ...
Java并发-Synchronized关键字.docx
06-26
为了解决这类问题，Java提供了`synchronized`关键字，它提供了一种锁机制，确保共享数据在同一时间只能被一个线程访问。在第一个示例中，没有使用`synchronized`，因此所有线程都可以并发地对`count`进行修改，导致...
Java 多线程与并发(5-26)-关键字- volatile详解.pdf
07-22
Java中的`volatile`关键字是多线程编程中一个重要的概念，它主要解决了两个核心问题：可见性和有序性。在Java内存模型（JMM）中，`volatile`关键字确保了线程之间的通信更加有效和安全。 **一、防止指令重排序** ...
Java中的关键字synchronized 详解
08-26
主要介绍了Java中的关键字synchronized，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java关键字volatile和synchronized作用和区别
08-30
Java关键字volatile和synchronized作用和区别 Java关键字volatile和synchronized是Java语言中两个常用的关键字，它们都是用来解决多线程编程中的同步问题的，但它们的作用和用法却有所不同。 volatile关键字是变量...
Java同步之synchronized
守得云开见明月
02-04 1万+
Java中可以使用关键字synchronized进行线程同步控制，实现关键资源顺序访问，避免由于多线程并发执行导致的数据不一致性等问题。synchronized的原理是对象监视器（锁），只有获取到监视器的线程才能继续执行，否则线程会等待获取监视器。Java中每个对象或者类都有一把锁与之相关联，对于对象来说，监视的是这个对象的实例变量，对于类来说，监视的是类变量（一个类本身是类Class的对象，所以
值得保存的 synchronized 关键字总结
weixin_34071713的博客
09-07 401
该文已加入开源文档：JavaGuide（一份涵盖大部分Java程序员所需要掌握的核心知识）。地址:github.com/Snailclimb/…. 本文是对 synchronized 关键字使用、底层原理、JDK1.6之后的底层优化以及和ReenTrantLock对比做的总结。如果没有学过 synchronized 关键字使用的话，阅读起来可能比较费力。两篇比较基础的讲解 synchroniz...
java的synchronized 关键字详解
m0_57659908的博客
04-13 1833
java的synchronized 关键字详解，介绍了synchronized 的原理，synchronized 的优化，即偏向锁，轻量级锁，自旋锁，锁消除，锁加重
详解synchronized关键字（Java）
weixin_66046886的博客
03-06 1725
这篇博客博主将详细地介绍地介绍Java中的synchronized关键字，坐好板凳发车啦~
理解Java中的synchronized关键字
weixin_43104619的博客
11-26 967
一、为什么需要synchronized关键字 在java中，免不了为了提升效率而使用多线程，而使用了多线程，就可能会出现线程不安全，导致数据错误等结果，在这种情况下，为了防止多线程下 线程不安全，就会采用synchronized（当然也有其他方法），使用synchronized的关键就是他会获取锁，在一个线程拥有锁的情况下，另一个线程只能等待，直到第一个线程释放了锁才能进入被synchroniz...
Java 并发编程之 Synchronized 关键字最全讲解
a1102325298的博客
09-11 6368
synchronized关键字 synchronized锁什么？ 锁对象。 锁的对象包括： this 临界资源对象 Class 类对象。 synchronized 除了保障原子性外，其实也保障了可见性。因为 synchronized 无论是同步的方法还是同步的代码块，都会先把主内存的数据拷贝到工作内存中，同步代码块结束，会把工作内存中的数据更新到主内存中，这样主内存中的数据一定...
java content关键字_Java中各种关键字-JAVA成长之路
06-08
Java语言中的关键字是指具有特殊含义的单词，这些单词在Java程序中具有特定的用途，不能作为标识符或变量名使用。Java中共有50个关键字，其中包括48个保留关键字和2个特殊关键字。 以下是Java中的各种关键字： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值