Java同步之synchronized

最新推荐文章于 2024-04-07 19:00:00 发布
最新推荐文章于 2024-04-07 19:00:00 发布
阅读量1.2w 收藏 9
点赞数
分类专栏： Java 进程与线程 文章标签： java Java JAVA java Java并发执行 synchronized 线程同步 锁监视器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongmi/article/details/8569886
版权
Java中可以使用关键字synchronized进行线程同步控制，实现关键资源顺序访问，避免由于多线程并发执行导致的数据不一致性等问题。synchronized的原理是对象监视器（锁），只有获取到监视器的线程才能继续执行，否则线程会等待获取监视器。Java中每个对象或者类都有一把锁与之相关联，对于对象来说，监视的是这个对象的实例变量，对于类来说，监视的是类变量（一个类本身是类Class的对象，所以与类关联的锁也是对象锁）。synchronized关键字使用方式有两种：synchronized方法和synchronized块。这两种监视区域都和一个引入对象相关联，当到达这个监视区域时，JVM就会锁住这个引用对象，当离开时会释放这个引用对象上的锁（有异常退出时，JVM会释放锁）。对象锁是JVM内部机制，只需要编写同步方法或者同步块即可，操作监视区域时JVM会自动获取锁或者释放锁。

首先来看同步方法的例子：

public class SynchronizedTest1 extends Thread
{
	private synchronized void testSynchronizedMethod()
	{
		for (int i = 0; i < 10; i++)
		{
			System.out.println(Thread.currentThread().getName()
					+ " testSynchronizedMethod:" + i);

			try
			{
				Thread.sleep(100);
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}

	@Override
	public void run()
	{
		testSynchronizedMethod();
	}

	public static void main(String[] args)
	{

                SynchronizedTest1 t = new SynchronizedTest1();
		t.start();
		t.testSynchronizedMethod();
	}
}
运行该程序输出结果为： 

main testSynchronizedMethod:0
main testSynchronizedMethod:1
main testSynchronizedMethod:2
main testSynchronizedMethod:3
main testSynchronizedMethod:4
main testSynchronizedMethod:5
main testSynchronizedMethod:6
main testSynchronizedMethod:7
main testSynchronizedMethod:8
main testSynchronizedMethod:9
Thread-0 testSynchronizedMethod:0
Thread-0 testSynchronizedMethod:1
Thread-0 testSynchronizedMethod:2
Thread-0 testSynchronizedMethod:3
Thread-0 testSynchronizedMethod:4
Thread-0 testSynchronizedMethod:5
Thread-0 testSynchronizedMethod:6
Thread-0 testSynchronizedMethod:7
Thread-0 testSynchronizedMethod:8
Thread-0 testSynchronizedMethod:9
可以看到testSynchronizedMethod方法在两个线程之间同步执行。

如果此时将main方法修改为如下所示，则两个线程并不能同步执行，因为此时两个线程的同步监视器不是同一个对象，不能起到同步的作用。 

public static void main(String[] args)
	{
		Thread t = new SynchronizedTest1();
		t.start();
		
		Thread t1 = new SynchronizedTest1();
		t1.start();
	}

此时输出结果如下所示： 

Thread-0 testSynchronizedMethod:0
Thread-1 testSynchronizedMethod:0
Thread-0 testSynchronizedMethod:1
Thread-1 testSynchronizedMethod:1
Thread-0 testSynchronizedMethod:2
Thread-1 testSynchronizedMethod:2
Thread-0 testSynchronizedMethod:3
Thread-1 testSynchronizedMethod:3
Thread-0 testSynchronizedMethod:4
Thread-1 testSynchronizedMethod:4
Thread-0 testSynchronizedMethod:5
Thread-1 testSynchronizedMethod:5
Thread-0 testSynchronizedMethod:6
Thread-1 testSynchronizedMethod:6
Thread-0 testSynchronizedMethod:7
Thread-1 testSynchronizedMethod:7
Thread-0 testSynchronizedMethod:8
Thread-1 testSynchronizedMethod:8
Thread-0 testSynchronizedMethod:9
Thread-1 testSynchronizedMethod:9
若想修改后的main方法能够在两个线程之间同步运行，需要将testSynchronizedMethod方法声明为静态方法，这样两个线程的监视器是同一个对象（类对象），能够同步执行。修改后的代码如下所示： 
public class SynchronizedTest1 extends Thread
{
	private static synchronized void testSynchronizedMethod()
	{
		for (int i = 0; i < 10; i++)
		{
			System.out.println(Thread.currentThread().getName()
					+ " testSynchronizedMethod:" + i);

			try
			{
				Thread.sleep(100);
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}

	@Override
	public void run()
	{
		testSynchronizedMethod();
	}

	public static void main(String[] args)
	{
		Thread t = new SynchronizedTest1();
		t.start();
		
		Thread t1 = new SynchronizedTest1();
		t1.start();
	}
}
输出结果如下： 

Thread-0 testSynchronizedMethod:0
Thread-0 testSynchronizedMethod:1
Thread-0 testSynchronizedMethod:2
Thread-0 testSynchronizedMethod:3
Thread-0 testSynchronizedMethod:4
Thread-0 testSynchronizedMethod:5
Thread-0 testSynchronizedMethod:6
Thread-0 testSynchronizedMethod:7
Thread-0 testSynchronizedMethod:8
Thread-0 testSynchronizedMethod:9
Thread-1 testSynchronizedMethod:0
Thread-1 testSynchronizedMethod:1
Thread-1 testSynchronizedMethod:2
Thread-1 testSynchronizedMethod:3
Thread-1 testSynchronizedMethod:4
Thread-1 testSynchronizedMethod:5
Thread-1 testSynchronizedMethod:6
Thread-1 testSynchronizedMethod:7
Thread-1 testSynchronizedMethod:8
Thread-1 testSynchronizedMethod:9
同步块的情况与同步方法类似，只是同步块将同步控制的粒度缩小，这样能够更好的发挥多线程并行执行的效率。
使用this对象控制同一对象实例之间的同步： 

public class SynchronizedTest2 extends Thread
{
	private void testSynchronizedBlock()
	{
		synchronized (this)
		{
			for (int i = 0; i < 10; i++)
			{
				System.out.println(Thread.currentThread().getName()
						+ " testSynchronizedBlock:" + i);

				try
				{
					Thread.sleep(100);
				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		}
	}

	@Override
	public void run()
	{
		testSynchronizedBlock();
	}

	public static void main(String[] args)
	{
		SynchronizedTest2 t = new SynchronizedTest2();
		t.start();

		t.testSynchronizedBlock();
	}
}
输出结果： 

main testSynchronizedBlock:0
main testSynchronizedBlock:1
main testSynchronizedBlock:2
main testSynchronizedBlock:3
main testSynchronizedBlock:4
main testSynchronizedBlock:5
main testSynchronizedBlock:6
main testSynchronizedBlock:7
main testSynchronizedBlock:8
main testSynchronizedBlock:9
Thread-0 testSynchronizedBlock:0
Thread-0 testSynchronizedBlock:1
Thread-0 testSynchronizedBlock:2
Thread-0 testSynchronizedBlock:3
Thread-0 testSynchronizedBlock:4
Thread-0 testSynchronizedBlock:5
Thread-0 testSynchronizedBlock:6
Thread-0 testSynchronizedBlock:7
Thread-0 testSynchronizedBlock:8
Thread-0 testSynchronizedBlock:9
使用class对象控制不同实例之间的同步： 

public class SynchronizedTest2 extends Thread
{
	private void testSynchronizedBlock()
	{
		synchronized (SynchronizedTest2.class)
		{
			for (int i = 0; i < 10; i++)
			{
				System.out.println(Thread.currentThread().getName()
						+ " testSynchronizedBlock:" + i);

				try
				{
					Thread.sleep(100);
				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		}
	}

	@Override
	public void run()
	{
		testSynchronizedBlock();
	}

	public static void main(String[] args)
	{
		Thread t = new SynchronizedTest2();
		t.start();

		Thread t2 = new SynchronizedTest2();
		t2.start();
	}
}

输出结果： 

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

使用synchronized关键字进行同步控制时，一定要把握好对象监视器，只有获得监视器的进程可以运行，其它都需要等待获取监视器。任何一个非null的对象都可以作为对象监视器，当synchronized作用在方法上时，锁住的便是对象实例（this）；当作用在静态方法时锁住的便是对象对应的Class实例。


总结：

synchronized是通过软件（JVM）实现的，简单易用，即使在JDK5之后有了Lock，仍然被广泛地使用。
synchronized实际上是非公平的，新来的线程有可能立即获得监视器，而在等待区中等候已久的线程可能再次等待，不过这种抢占的方式可以预防饥饿。
synchronized只有锁只与一个条件（是否获取锁）相关联，不灵活，后来Condition与Lock的结合解决了这个问题。
多线程竞争一个锁时，其余未得到锁的线程只能不停的尝试获得锁，而不能中断。高并发的情况下会导致性能下降。ReentrantLock的lockInterruptibly()方法可以优先考虑响应中断。 一个线程等待时间过长，它可以中断自己，然后ReentrantLock响应这个中断，不再让这个线程继续等待。有了这个机制，使用ReentrantLock时就不会像synchronized那样产生死锁了。


参考资料：

JAVA并发编程学习笔记之synchronized
深入JVM锁机制1-synchronized

java 对象锁

星星浩然
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized同步方法
Waiting_Mr_Liu的博客
08-17 576
2.3. synchronized同步方法 2.3.1. synchronized方法的锁对象 1）先持有先运行 Synchronized取得的锁都是对象锁，而不是把一段代码/方法作为锁，因此在多线程中，哪个线程先执行带有synchronized关键字修饰的方法，哪个方法就持有该方法所属对象的锁，其他线程只能呈等待状态。但是，前提是：多个线程访问的是同一个对象，如果多个线程访问的不是同一个对象，JVM则会创建出多个对象锁。 样例代码： public class MultiObjectLock { p
聊聊Java关键字synchronized
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-13 4121
具体例子，某段线程得到锁Test.class之后，执行临界代码逻辑，可能会先执行变量b初始化的逻辑，在执行a变量初始化的逻辑，但是最终结果都会执行a+b的逻辑。每个线程使用synchronized获得锁操作临界资源时，首先需要获取临界资源的值，为了保证临界资源的值是最新的，JMM模型规定线程必须将本地工作内存清空，到共享内存中加载最新的进行操作。正是由于锁互斥的失败，导致两个线程同时到临界区域加载资源，获得的count都是0，经过自增后都是1，导致数据少了1。
synchronized详解
Linging_24的博客
12-03 1805
1、并发编程会出现原子性、可见性、有序性问题。 原子性：在一次或多次操作中，要么所有的操作都执行并且不会受其它因素干扰而中断，要么所有的操作都不执行。在多线程环境下，线程对共享变量的操作，要么成功，要么失败，不会受其它线程的干扰。 可见性：在多线程环境下，某个线程对共享变量的修改，其它的线程可以知道并获取最新修改的值。 有序性：指程序中代码的执行顺序，java在编译时和运行时对代码进行优化，会导致程序的最终执行顺序不一定是我们Java代码编写时的顺序。 2、JVM内存模型 Java内存模型，是Java虚拟机
Java synchronized（详细）
最新发布
小电玩
04-07 818
在Java中，`synchronized`关键字用于解决多线程并发访问共享资源时可能出现的线程安全问题。
Java线程基础之Synchronized
weixin_43326254的博客
08-08 303
什么是Synchronized，Synchronized的作用
synchronized总结
奔波儿东
03-01 1510
查看synchronized修饰过的代码块编译后的字节码，会发现被synchronized修饰过的代码块前后会生成两个字节码指令：monitorenter、monitorexit； 这两个字节码指令的含义：当JVM执行到monitorenter和monitorexit两个指令实现同步。 monitorenter ： 每个对象都与一个监视器锁（monitor）相关联，monitor才会被锁定。线程执行monitorenter指令时会尝试获取monitor的所有权。 每个对象维护者一个记录着被锁定次数的计数
详细解读java同步之synchronized解析
08-26
【Java同步之synchronized解析】 Java中的`synchronized`关键字是实现多线程同步的重要机制，它确保了在并发环境中对共享资源的访问是线程安全的。以下是对`synchronized`的详细解读： ### 1. synchronized的特性 ...
Java多线程synchronized同步方法详解
08-24
主要介绍了Java多线程synchronized同步方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
浅析Java多线程同步synchronized
08-27
Java多线程同步synchronized是Java编程语言中最基本的同步机制之一。它通过锁机制来实现多线程之间的同步，确保多个线程访问共享资源时的安全性。 在Java中，synchronized关键字可以用来同步代码块或方法。同步代码...
java多线程编程之使用Synchronized块同步方法
09-04
Java多线程编程中，`synchronized`关键字是实现线程同步的关键，它可以防止多个线程同时访问共享资源，从而避免数据不一致的问题。在Java中，`synchronized`有两种使用方式：同步方法和同步代码块。 1. 同步方法： ...
synchronized 同步
sifanchao的博客
11-14 987
同步问题的引出 需求：多个线程同时卖票 class MyThread implements Runnable { private int ticket = 10; @Override public void run() { while (this.ticket &amp;amp;amp;gt; 0) { try { ...
java线程同步的作用_Java并发编程之线程同步
weixin_39736934的博客
02-17 310
线程安全就是防止某个对象或者值在多个线程中被修改而导致的数据不一致问题，因此我们就需要通过同步机制保证在同一时刻只有一个线程能够访问到该对象或数据，修改数据完毕之后，再将最新数据同步到主存中，使得其他线程都能够得到这个最新数据。下面我们就来了解Java一些基本的同步机制。volatile关键字Java提供了一种稍弱的同步机制即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声...
关于synchronized同步方法
maimai的博客
05-04 371
修饰同步方法：作用于当前实例加锁，进入同步代码前要获得当前实例的锁。 public class TestThread { public synchronized void car1(){ System.out.println(Thread.currentThread()+"获得资源"); try { Thread.currentThread().sleep(3000); } catch (InterruptedExcepti
Synchronized同步方法
u014785687的博客
03-07 3516
“非线程安全”其实会在多个线程对同一个对象中的实例变量进行并发访问时发生，产生的后果就是“脏读”，也就是取到的数据其实是被更改过的。1**、方法内的变量为线程安全的** 方法内部的私有变量，则不存在“非线程安全”的问题，所得结果也就是“线程安全”的。2、实例变量非线程安全
java 同步锁（synchronized）的正确使用姿势
AndroFarmer的专栏
04-05 7489
关于线程安全，线程锁的使用
java中用synchronized实现同步处理
坚持不懈做贡献
11-21 1512
synchronized Java中提供synchronized关键字实现同步处理，用synchoronized可以修饰代码块，修饰方法，来完成对 对象加锁，对类加锁的操作。synchoronized是重量级锁。意思就是当有一个线程A进入时其他想访问的线程阻塞师等待，等待该线程A执行完整个加锁区间，系统自动释放锁，并唤醒等待的其他线程竞争锁。 对象锁 synchronized修饰同步代码块 --锁...
synchronized（偏向锁和轻量级锁）（TODO）
anlao4870的博客
07-07 845
synchronized 　　JDK1.6对synchronized进行了各种优化，性能已经和ReentrantLock差不多了。 　　Java中的每一个对象都可以作为锁。具体表现为以下3种形式。 对于普通同步方法，锁是当前实例对象。 对于静态同步方法，锁是当前类的Class对象。 对于同步方法块，锁是Synchonized括号里配置的对象。 　　JVM基于进入和退出...
synchronized代码块调度
tterminator的专栏
05-08 626
一、结论被synchronized关键字修饰的代码块在执行过程中也可能被调度，也即被sysnchronized修饰的代码块并不是执行完毕后才会被调度。二、结论验证1.用于测试被synchronized修饰的两条语句是否执行完毕后才被调度的runnable.package synchronizedSwitch;import java.util.concurrent.atomic.AtomicInteg
java同步锁synchronized使用案例
08-30
Java中的synchronized关键字是一种用于实现同步的机制。它可以应用于方法和代码块，以确保在同一时刻只有一个线程可以访问共享资源。 以下是一些使用synchronized关键字的案例： 1. 多线程访问共享资源：考虑一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值