从头认识多线程-2.19 synchronized (new object())同步时各种不同类别的监视器以及其引起的问题(常量池的影响)

最新推荐文章于 2022-07-06 16:01:14 发布
最新推荐文章于 2022-07-06 16:01:14 发布
阅读量4.1k 收藏 1
点赞数
分类专栏： 多线程 从头认识多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/raylee2007/article/details/51387567
版权

在这里先向读者们道歉，由于之前的不严谨，从头认识多线程-2.15 证明使用整数属性域作为多线程监视器是不同步的这一章里面的例子有所偏差，导致结论出现偏差，在这里再次道歉，因此，才有今天的这一个章节出现。

这一章节我们来讨论一下synchronized (new object())同步时各种不同类别的监视器以及其引起的问题.

1.使用整数作为属性域，而且该属性域就是多线程同步的监视器

package com.ray.deepintothread.ch02.topic_19;

/**
 * 
 * @author RayLee
 *
 */
public class MonitorOfSynch {
	public static void main(String[] args) throws InterruptedException {
		MyService myService = new MyService();
		ThreadOne threadOne = new ThreadOne(myService);
		Thread thread = new Thread(threadOne);
		thread.setName("thread A");
		thread.start();
		ThreadTwo threadTwo = new ThreadTwo(myService);
		Thread thread2 = new Thread(threadTwo);
		thread2.setName("thread B");
		thread2.start();
	}
}

class ThreadOne implements Runnable {

	private MyService myService;

	public ThreadOne(MyService myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateA();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadTwo implements Runnable {

	private MyService myService;

	public ThreadTwo(MyService myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateB();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class MyService {

	private Integer id = 0;

	public void updateA() throws InterruptedException {
		synchronized (id) {
			for (int i = 0; i < 5; i++) {
				System.out.println("id:" + id);
				System.out.println(Thread.currentThread().getName() + " " + id++);
				Thread.sleep(50);
				System.out.println("-------------------");
			}
		}
	}

	public void updateB() throws InterruptedException {
		synchronized (id) {
			for (int i = 0; i < 5; i++) {
				System.out.println("id:" + id);
				System.out.println(Thread.currentThread().getName() + " " + id++);
				Thread.sleep(100);
				System.out.println("-------------------");
			}
		}
	}

}

输出：

id:0
thread A 0
id:1
thread B 1
-------------------
id:2
thread A 2
-------------------
-------------------

//注意下面的输出
id:3
thread B 3
id:3
thread A 4
-------------------
id:5
thread A 5
-------------------
-------------------
id:6
thread B 6
id:6
thread A 7
-------------------
-------------------
id:8
thread B 8
-------------------
id:9
thread B 9
-------------------


从输出我们可以看见，毫无疑问的是，上面出现了脏读，两个方法之间不同步。


2.使用字符串作为属性域，而且该属性域就是多线程同步的监视器

package com.ray.deepintothread.ch02.topic_19;

/**
 * 
 * @author RayLee
 *
 */
public class MonitorOfSynch3 {
	public static void main(String[] args) throws InterruptedException {
		MyService3 myService = new MyService3();
		ThreadFive threadFive = new ThreadFive(myService);
		Thread thread = new Thread(threadFive);
		thread.setName("thread A");
		thread.start();
		ThreadSix threadSix = new ThreadSix(myService);
		Thread thread2 = new Thread(threadSix);
		thread2.setName("thread B");
		thread2.start();
	}
}

class ThreadFive implements Runnable {

	private MyService3 myService;

	public ThreadFive(MyService3 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateA();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadSix implements Runnable {

	private MyService3 myService;

	public ThreadSix(MyService3 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateB();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class MyService3 {

	private String name = "ray";

	public void updateA() throws InterruptedException {
		synchronized (name) {
			for (int i = 0; i < 5; i++) {
				System.out.println("name:" + name);
				// 修改监视器
				name += "-" + i;
				System.out.println(Thread.currentThread().getName() + " " + name);
				Thread.sleep(50);
				// 恢复原形
				name = "ray";
				System.out.println("-------------------");
			}
		}
	}

	public void updateB() throws InterruptedException {
		synchronized (name) {
			for (int i = 0; i < 5; i++) {
				System.out.println("name:" + name);
				// 修改监视器
				name += "-" + i;
				System.out.println(Thread.currentThread().getName() + " " + name);
				Thread.sleep(100);
				// 恢复原形
				name = "ray";
				System.out.println("-------------------");
			}
		}
	}

}

输出：

//注意第一个的输出

name:ray
thread A ray-0
name:ray-0
thread B ray-0-0
-------------------
name:ray
thread A ray-1
-------------------
name:ray
thread A ray-2
-------------------
name:ray
thread B ray-1
-------------------
name:ray
thread A ray-3
-------------------
-------------------
name:ray
name:ray
thread A ray-2-4
thread B ray-2
-------------------
-------------------
name:ray
thread B ray-3
-------------------
name:ray
thread B ray-4
-------------------


从输出我们可以看见，毫无疑问的是，上面出现了脏读，两个方法之间不同步。


3.使用自有对象作为属性域，而且该属性域就是多线程同步的监视器

package com.ray.deepintothread.ch02.topic_19;

/**
 * 
 * @author RayLee
 *
 */
public class MonitorOfSynch2 {
	public static void main(String[] args) throws InterruptedException {
		MyService2 myService = new MyService2();
		ThreadThree threadThree = new ThreadThree(myService);
		Thread thread = new Thread(threadThree);
		thread.setName("thread A");
		thread.start();
		ThreadFour threadFour = new ThreadFour(myService);
		Thread thread2 = new Thread(threadFour);
		thread2.setName("thread B");
		thread2.start();
	}
}

class ThreadThree implements Runnable {

	private MyService2 myService;

	public ThreadThree(MyService2 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateA();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadFour implements Runnable {

	private MyService2 myService;

	public ThreadFour(MyService2 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateB();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class MyService2 {

	private Person person = new Person();

	public void updateA() throws InterruptedException {
		synchronized (person) {
			for (int i = 0; i < 5; i++) {
				System.out.println("person name:" + person.getName());
				// 设置新的属性
				person.setId(i);
				person.setName(person.getName() + "-" + i);
				System.out.println(Thread.currentThread().getName() + " " + person.getName());
				Thread.sleep(50);
				// 复原对象
				person.setId(0);
				person.setName("ray");
				System.out.println("-------------------");
			}
		}
	}

	public void updateB() throws InterruptedException {
		synchronized (person) {
			for (int i = 0; i < 5; i++) {
				System.out.println("person name:" + person.getName());
				// 设置新的属性
				person.setId(i);
				person.setName(person.getName() + "-" + i);
				System.out.println(Thread.currentThread().getName() + " " + person.getName());
				Thread.sleep(100);
				// 复原对象
				person.setId(0);
				person.setName("ray");
				System.out.println("-------------------");
			}
		}
	}

}

/**
 * 自有对象
 * 
 * @author R
 *
 */
class Person {
	private int id = 0;
	private String name = "ray";

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

输出：

person name:ray
thread A ray-0
-------------------
person name:ray
thread A ray-1
-------------------
person name:ray
thread A ray-2
-------------------
person name:ray
thread A ray-3
-------------------
person name:ray
thread A ray-4
-------------------
person name:ray
thread B ray-0
-------------------
person name:ray
thread B ray-1
-------------------
person name:ray
thread B ray-2
-------------------
person name:ray
thread B ray-3
-------------------
person name:ray
thread B ray-4
-------------------


从输出我们可以看见，虽然我们改变了监视器，但是，上面没有出现了脏读，两个方法之间是同步的。


4.使用时间作为属性域，而且该属性域就是多线程同步的监视器

package com.ray.deepintothread.ch02.topic_19;

import java.util.Date;

/**
 * 
 * @author RayLee
 *
 */
public class MonitorOfSynch4 {
	public static void main(String[] args) throws InterruptedException {
		MyService4 myService = new MyService4();
		ThreadSeven threadSeven = new ThreadSeven(myService);
		Thread thread = new Thread(threadSeven);
		thread.setName("thread A");
		thread.start();
		ThreadEight threadEight = new ThreadEight(myService);
		Thread thread2 = new Thread(threadEight);
		thread2.setName("thread B");
		thread2.start();
	}
}

class ThreadSeven implements Runnable {

	private MyService4 myService;

	public ThreadSeven(MyService4 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateA();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadEight implements Runnable {

	private MyService4 myService;

	public ThreadEight(MyService4 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateB();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class MyService4 {

	private Date date = new Date();

	public void updateA() throws InterruptedException {
		synchronized (date) {
			for (int i = 0; i < 5; i++) {
				System.out.println("date:" + date.toString());
				date = new Date();
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName() + " " + date.toString());
				Thread.sleep(500);
				System.out.println("-------------------");
			}
		}
	}

	public void updateB() throws InterruptedException {
		synchronized (date) {
			for (int i = 0; i < 5; i++) {
				System.out.println("date:" + date.toString());
				date = new Date();
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName() + " " + date.toString());
				Thread.sleep(1000);
				System.out.println("-------------------");
			}
		}
	}

}

输出：

date:Thu May 12 21:13:49 CST 2016
thread A Thu May 12 21:13:49 CST 2016
-------------------
date:Thu May 12 21:13:49 CST 2016
thread A Thu May 12 21:13:50 CST 2016
-------------------
date:Thu May 12 21:13:50 CST 2016
thread A Thu May 12 21:13:52 CST 2016
-------------------
date:Thu May 12 21:13:52 CST 2016
thread A Thu May 12 21:13:53 CST 2016
-------------------
date:Thu May 12 21:13:53 CST 2016
thread A Thu May 12 21:13:55 CST 2016
-------------------
date:Thu May 12 21:13:55 CST 2016
thread B Thu May 12 21:13:56 CST 2016
-------------------
date:Thu May 12 21:13:56 CST 2016
thread B Thu May 12 21:13:58 CST 2016
-------------------
date:Thu May 12 21:13:58 CST 2016
thread B Thu May 12 21:14:00 CST 2016
-------------------
date:Thu May 12 21:14:00 CST 2016
thread B Thu May 12 21:14:02 CST 2016
-------------------
date:Thu May 12 21:14:02 CST 2016
thread B Thu May 12 21:14:04 CST 2016
-------------------


从输出我们可以看见，虽然我们改变了监视器，但是，上面没有出现了脏读，两个方法之间是同步的。


5.使用容器作为属性域，而且该属性域就是多线程同步的监视器

package com.ray.deepintothread.ch02.topic_19;

import java.util.ArrayList;

/**
 * 
 * @author RayLee
 *
 */
public class MonitorOfSynch5 {
	public static void main(String[] args) throws InterruptedException {
		MyService5 myService = new MyService5();
		ThreadNine threadNine = new ThreadNine(myService);
		Thread thread = new Thread(threadNine);
		thread.setName("thread A");
		thread.start();
		ThreadTen threadTen = new ThreadTen(myService);
		Thread thread2 = new Thread(threadTen);
		thread2.setName("thread B");
		thread2.start();
	}
}

class ThreadNine implements Runnable {

	private MyService5 myService;

	public ThreadNine(MyService5 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateA();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ThreadTen implements Runnable {

	private MyService5 myService;

	public ThreadTen(MyService5 myService) {
		this.myService = myService;
	}

	@Override
	public void run() {
		try {
			myService.updateB();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class MyService5 {

	private ArrayList<Integer> list = new ArrayList<>();

	public void updateA() throws InterruptedException {
		synchronized (list) {
			for (int i = 0; i < 5; i++) {
				System.out.println("list size:" + list.size());
				list.add(i);
				System.out.println(Thread.currentThread().getName() + " " + list.size());
				Thread.sleep(50);
				System.out.println("-------------------");
			}
		}
	}

	public void updateB() throws InterruptedException {
		synchronized (list) {
			for (int i = 0; i < 5; i++) {
				System.out.println("list size:" + list.size());
				list.add(i);
				System.out.println(Thread.currentThread().getName() + " " + list.size());
				Thread.sleep(100);
				System.out.println("-------------------");
			}
		}
	}

}


输出：

list size:0
thread A 1
-------------------
list size:1
thread A 2
-------------------
list size:2
thread A 3
-------------------
list size:3
thread A 4
-------------------
list size:4
thread A 5
-------------------
list size:5
thread B 6
-------------------
list size:6
thread B 7
-------------------
list size:7
thread B 8
-------------------
list size:8
thread B 9
-------------------
list size:9
thread B 10
-------------------


从输出我们可以看见，虽然我们改变了监视器，但是，上面没有出现了脏读，两个方法之间是同步的。


6.现象结论

使用整数或者字符串作为属性域，并且该属性域作为多线程同步的监视器，这个时候，方法间是不同步的，而其他对象均可同步。


7.为什么？

因为jvm对于某个段的整数或者字符串做了相应的优化

package com.ray.deepintothread.ch02.topic_19;

public class ComparisonInteger {
	public static void main(String[] args) {
		Integer a = 0;
		Integer b = 0;
		System.out.println(a == b);
		Integer c = 1000;
		Integer d = 1000;
		System.out.println(c == d);
	}
}

输出：

true
false


package com.ray.deepintothread.ch02.topic_19;

public class ComparisonString {
	public static void main(String[] args) {
		String a = "a";
		String b = "a";
		System.out.println(a == b);
		String c = new String("a");
		String d = new String("a");
		System.out.println(c == d);
	}
}

输出：

true
false


上面的两组代码证明了jvm存在常量池，而整数和字符串都有一部分属于常量池，这只jvm自有的优化，在使用这两种对象作为同步监视器，则会出现不同步的现象。

大家这里必须注意这个地方。


总结：这一章节讨论了各种不同类别的监视器以及所引起的问题。


这一章节就到这里，谢谢

------------------------------------------------------------------------------------

我的github：https://github.com/raylee2015/DeepIntoThread


目录：http://blog.csdn.net/raylee2007/article/details/51204573




李灵晖
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
java多线程编程之使用Synchronized块同步变量
09-04
我们可以通过synchronized块来同步特定的静态或非静态方法。要想实现这种需求必须为这些特性的方法定义一个类变量，然后将这些方法的代码用synchronized块括起来，并将这个类变量作为参数传入synchronized块
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
Java并发编程学习笔记3——synchronized原理
weixin_44623055的博客
06-10 354
目录1、共享带来的问题1.1、临界区（Critical Section）1.2、竞态条件（Race Condition）2、synchronize解决方案2.1、应用之互斥2.2、synchronized2.3、面向对象改进3、方法上的synchronized4、变量的线程安全分析4.1、成员变量和静态变量是否线程安全？4.2、局部变量是否线程安全？4.3、常见线程安全类4.3.1、线程安全类方法的组合4.3.2、不可变类线程安全性5、Monitor（锁）概念5.1、Java对象头5.2、Monitor（锁
Synchronized原理
jjk45655的博客
06-09 142
mark
从头认识多线程-2.14 由同步的synchronized (newobject()) 引起的异步现象和脏读
raylee2007的专栏
05-07 5525
这一章节我们来讨论一下由同步的synchronized (newobject()) 引起的异步现象。1.代码清单package com.ray.deepintothread.ch02.topic_14; /** * * @author RayLee * */ public class AsynchOfSynchWithUnSameObject { public static void
Synchronized的实现
qq_55768596的博客
05-01 413
1.Synchronized 1.1 加了synchronized的字节码指令和java源代码 synchronized(new Object()){ int a = 1;int b = 2; System.out.println(add(a,b)); } 由上图：被Synchronized修饰过的代码块，会生成monitorenter(监视器)字节码指令和monitorexit(监视器退出)字节码指令，当虚拟机执行到监视器指令的时候，就要...
synchronized底层原理
weixin_42412601的博客
10-07 526
目录1、用户态与内核态2、使用工具查看对象的内存布局3、synchronized字节码4、监视器对象(管程对象或Monitor)1、EntryList阻塞队列2、WaitSet等待集合5、锁升级1、JDK对锁的优化2、锁对象头 - Mark Work部分3、synchornized锁的升级1、偏向锁 https://www.jb51.net/article/183984.htm https://blog.csdn.net/mulinsen77/article/details/88635558 https:/
从头认识多线程-2.15 解决由同步的synchronized (newobject()) 引起的脏读的方法
raylee2007的专栏
05-08 3876
这一章节我们来讨论一下解决由同步的synchronized (newobject()) 引起的异步现象和脏读的方法。1.代码清单package com.ray.deepintothread.ch02.topic_14; /** * * @author RayLee * */ public class DirtyRead { public static void main(String
synchronized同步
GuoSongdeveloping的博客
05-15 103
锁的类型 （1）显式锁：ReentrantLock ，实现juc 里Lock ,实现的是基于ReentrantLock类中的lock()和unlock(0方法 （2）隐式锁：Synchronized 加锁的机制，jvm的内置锁，它不需要手动进行加锁，jvm会自动加锁 jvm内置锁通过synchronized使用 ，通过内部的（监视器锁）来实现，基于进入进入与退出Monitor对象的实现方法与代码同步，监视起的底层依赖于操作系统的mutex lock(互斥锁）实现，是一个重要的重量级的锁，性能比较低
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
java多线程编程之使用Synchronized块同步方法
09-04
synchronized块来同步一个对象变量,也可以使用synchronized块来同步类中的静态方法和非静态方法,下面使用Synchronized块同步方法
java synchronized关键字解惑
王铮Nio的博客
06-02 160
    synchronized关键字用于java编程中的线程同步。在详细讲之前，我想闲谈谈我对java同步的理解。对于每个类来说，java有两条设定好的独一无二的同步路线，两把锁：一个是类对象的同步也就是对象锁（暂称为锁A），一个是类的同步也就是类锁（暂称为锁B）。什么意思呢，首先说类对象的同步，也就是对象锁。类对象的同步也就是说每个类对象都有一条同步路线，好比一辆车，任何添加了synchron...
代码质量管理
qq_37705525的博客
07-06 8661
代码质量管理
Java 多线程（二） synchronized关键字
wjs_marvin的博客
01-25 224
1.概要 线程安全：多个线程同时访问公共对象或者同一个对象时，采用了加锁的机制，对公共数据进行保护，直到线程对该数据使用完。 非线程安全：多个线程同时访问公共对象或者同一个对象时，发生数据不一致或者数据污染 脏读：读到的数据其实是被更改过的，数据不一致或者数据污染。 2.Synchronized方法与锁对象 synchronized 1.
synchronized用法解析
hqqkkc的博客
10-21 245
synchronized详解使用同步代码块synchronized (this) {}--对象锁Object obj = new Object(); synchronized(obj){...} 对象锁synchronized(.class){...} 类锁，锁的是这个类。修饰实例方法 对象锁修饰静态方法 类锁测试代码 多个线程执行对同一个Java对象访问时候，为了保证数据的有效性，通常会使用synchronized关键字，俗称多线程安全。 synchronized从语法上一共有三种语法，修饰静态方法
synchronized(object) 的作用
HeatDeath的博客
03-18 893
class Test { private int x=0; private Object lockObject = new Object(); public void incBlock() { synchronized(lockObject) { x++; } System.out.println("x="+x); } public vo...
深入理解Synchronized
qq_24466549的博客
05-17 354
前言 Synchronized想必大家在工作中一定有接触过，它算是Java并发场景下实现多线程安全一种比较直接的操作。有人会说它慢，确实。在JDK1.6之前，它有另一个名称叫做：重量级锁。但是从1.6版本起，它就在不断被优化。现如今已经是很成熟的并发安全技术；所以关于Synchronized的考察也常常成为面试官青睐的话题。 本文我们会使用图解的方式解析Synchronized的使用和原理，让我们开始吧~ 对象锁和类锁 什么是Synchronized？Synchronized是Java中的一个关
从头认识多线程-2.1 局部变量与实例变量的线程安全
raylee2007的专栏
04-21 8095
这一章节我们来讨论一下局部变量与实例变量的线程安全。1.结论局部变量线程安全的实例变量不是线程安全的2.代码清单package com.ray.deepintothread.ch02.topic_1; public class ThreadSafeOfLocalVariable { public static void main(String[] args) throws Interrupte
jmu-java-07多线程-同步访问
最新发布
06-28
如果我理解正确的话，您的问题是关于JMU Java 07多线程同步访问的。以下是我的回答： 多线程编程是指在一个程序中同时执行多个线程的编程技术。多线程编程在提高程序性能、增强程序交互性等方面有很大的优势，但也...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值