Java关键字 -- synchronized

最新推荐文章于 2024-06-15 16:22:13 发布
最新推荐文章于 2024-06-15 16:22:13 发布
阅读量10w+ 收藏 91
点赞数 14
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Amosstan/article/details/120161969
版权

一、介绍

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
关注
  • 14
    点赞
  • 踩
  • 91
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
synchronized用法详解
ganmaotong的博客
06-01 1万+
目录1.线程安全问题2.使用同步机制管理共享数据3.synchronized原理概述3.1 同步代码块的实现原理3.2 同步方法的原理4.synchronized的使用4.1同步代码块 4.2同步普通方法4.3同步静态方法5.synchronized的不可中断性与可重入性5.1 不可中断性5.2 可重入性6.使用synchronized的注意事项6.1注意synchronized同步块的粒度 6.2 对 String 加锁 6.3 对Integer、Long、Short等包装类加锁 线程允许程
Java 多线程与并发(4-26)-关键字- synchronized详解.pdf
07-21
"Java 多线程与并发(4-26)-关键字- synchronized详解" Java 多线程与并发中的 synchronized 关键字是实现同步块的互斥访问和线程的阻塞及唤醒等工作的重要工具。下面将对 synchronized 关键字进行详细分析。 ...
Synchronized 关键字原理
热门推荐
钱立清的博客
10-13 6万+
众所周知synchronized关键字是解决并发问题常用解决方案，有以下四种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。 修饰方法，即同步方法，其作用的范围是整个方法，作用的对象是调...
深入理解Java中的synchronized关键字
最新发布
weixin_74268571的博客
06-15 1153
synchronized的详细讲解和底层实现，以及synchronized的同步机制，synchronized的重入和synchronized的异常演示
聊聊Java关键字synchronized
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-13 4183
具体例子，某段线程得到锁Test.class之后，执行临界代码逻辑，可能会先执行变量b初始化的逻辑，在执行a变量初始化的逻辑，但是最终结果都会执行a+b的逻辑。每个线程使用synchronized获得锁操作临界资源时，首先需要获取临界资源的值，为了保证临界资源的值是最新的，JMM模型规定线程必须将本地工作内存清空，到共享内存中加载最新的进行操作。正是由于锁互斥的失败，导致两个线程同时到临界区域加载资源，获得的count都是0，经过自增后都是1，导致数据少了1。
Java.synchronized
m0_58407085的博客
04-19 987
偏向锁就是一个标志，在对象头存储当前锁偏向的线程，当一个线程访问时，会先判断这个标志是否等于当前线程，如果等于当前线程，那就直接获得锁，如果为空，就把当前锁的对象头，设置成自己，如果不等于自己，锁就会升级）。（1）synchronized的特性 原子性，内存可见性，有序性（指令重排序），非公平锁，可重入锁，不可中断（这里的不可中断不是指线程不能中断，而是指当拿不到锁的时候，这个阻塞的过程不可以中断）。5.synchronized的锁机制/synchronized的锁升级，锁膨胀，锁消除，锁粗化。
synchronized详解
fwdwqdwq的博客
03-16 4559
对synchronized的了解 synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时.
Java并发-Synchronized关键字.docx
06-26
为了解决这类问题，Java提供了`synchronized`关键字，它提供了一种锁机制，确保共享数据在同一时间只能被一个线程访问。在第一个示例中，没有使用`synchronized`，因此所有线程都可以并发地对`count`进行修改，导致...
Java并发编程---synchronized关键字
10-30
Java并发编程---synchronized关键
java关键字Synchronized详解
07-04
Java中的`synchronized`关键字是实现线程同步的关键机制，它保证了在多线程环境下，对共享资源的访问是互斥的，防止了数据竞争和不一致的问题。synchronized通过锁的概念来控制对代码块或方法的访问，分为两种形式：...
java synchronized关键字的用法
09-02
0; public synchronized void...综上所述，synchronized 关键字是 Java 中实现线程同步的重要手段，它通过加锁机制保证了线程安全。然而，在实际应用中，我们需要根据具体场景选择合适的同步策略，以兼顾性能和正确性。
Java中的关键字synchronized 详解
08-26
主要介绍了Java中的关键字synchronized，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java关键字——synchronized
weixin_42547014的博客
07-21 2899
什么是synchronize 如何使用 底层原理 做过那些优化 对象在内存中 用户态？内核态？ 为什么效率低 一、认识 Synchronized synchornized 是 Java 中的一个关键字，解决的是多个线程之间访问资源的同步性，synchronized 关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 重量级锁：其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线.
Java线程基础之Synchronized
weixin_43326254的博客
08-08 333
什么是Synchronized，Synchronized的作用
Synchronized三种使用方式
m0_59164927的博客
08-14 1459
两个方法methods01锁住test实例对象,methods02锁住test02对象，methods02没有sleep先打印。结果说明:两个方法调用同一个锁，即锁的this，被methods01抢夺后，methods02进入等待。methods01拿类锁，methods02拿对象锁,methods02不用等待。static锁住类对象，只有一个,需要等待methods01执行完。hello没加锁不用等待methods01执行完。结果说明：methods01先调用，先执行。...
synchronized总结
奔波儿东
03-01 1511
查看synchronized修饰过的代码块编译后的字节码，会发现被synchronized修饰过的代码块前后会生成两个字节码指令：monitorenter、monitorexit； 这两个字节码指令的含义：当JVM执行到monitorenter和monitorexit两个指令实现同步。 monitorenter ： 每个对象都与一个监视器锁（monitor）相关联，monitor才会被锁定。线程执行monitorenter指令时会尝试获取monitor的所有权。 每个对象维护者一个记录着被锁定次数的计数
java的synchronized 关键字详解
m0_57659908的博客
04-13 1779
java的synchronized 关键字详解，介绍了synchronized 的原理，synchronized 的优化，即偏向锁，轻量级锁，自旋锁，锁消除，锁加重
Java并发编程知识点总结（四）——Synchronized实现原理以及优化
XHHP
09-04 918
synchronized原理 我们可以知道线程的安全问题主要来自于Java内存模型的设计，也就是主内存和各工作内存之间而导致的内存可见性问题，以及重排序导致的问题。 synchronized关键字可以使得线程依次排队操纵共享变量。但是这种机制会导致效率比较低下，并发程度低。 下面我们就具体来看一下synchronized关键字 （二）、synchronized实现原理 2.1 synchroized的作用范围...
java content关键字_Java中各种关键字-JAVA成长之路
06-08
Java语言中的关键字是指具有特殊含义的单词，这些单词在Java程序中具有特定的用途，不能作为标识符或变量名使用。Java中共有50个关键字，其中包括48个保留关键字和2个特殊关键字。 以下是Java中的各种关键字： 1. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值