从头认识多线程-2.24 修改监视器对同步的影响

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

这一章节我们来讨论一下修改监视器对同步的影响。

1.不修改监视器，同步的

package com.ray.deepintothread.ch02.topic_24;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfStaticInnerClass {

	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			public void run() {
				MyService.updateA();
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				MyService.updateB();
			}
		});
		thread2.start();
	}
}

class MyService {

	private static int id = 0;

	private static String lock = "a";

	public static void updateA() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " id:" + id++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void updateB() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " id:" + id++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

输出：

Thread name:Thread-0 id:0
Thread name:Thread-0 id:1
Thread name:Thread-0 id:2
Thread name:Thread-0 id:3
Thread name:Thread-0 id:4
Thread name:Thread-0 id:5
Thread name:Thread-0 id:6
Thread name:Thread-0 id:7
Thread name:Thread-0 id:8
Thread name:Thread-0 id:9
Thread name:Thread-1 id:10
Thread name:Thread-1 id:11
Thread name:Thread-1 id:12
Thread name:Thread-1 id:13
Thread name:Thread-1 id:14
Thread name:Thread-1 id:15
Thread name:Thread-1 id:16
Thread name:Thread-1 id:17
Thread name:Thread-1 id:18
Thread name:Thread-1 id:19


2.当修改发生在线程开始的时候，把同步变成异步

package com.ray.deepintothread.ch02.topic_24;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfStaticInnerClass2 {

	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			public void run() {
				MyService2.updateA();
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				MyService2.updateB();
			}
		});
		thread2.start();
	}
}

class MyService2 {

	private static int a = 0;

	private static Object lock = new Object();

	public static void updateA() {
		synchronized (lock) {
			lock = new Object();
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void updateB() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

输出：

Thread name:Thread-1 a:0
Thread name:Thread-0 a:0
Thread name:Thread-1 a:1
Thread name:Thread-0 a:2
Thread name:Thread-0 a:3
Thread name:Thread-1 a:4
Thread name:Thread-0 a:5
Thread name:Thread-1 a:6
Thread name:Thread-0 a:7
Thread name:Thread-1 a:8
Thread name:Thread-1 a:9
Thread name:Thread-0 a:10
Thread name:Thread-0 a:11
Thread name:Thread-1 a:12
Thread name:Thread-1 a:13
Thread name:Thread-0 a:14
Thread name:Thread-0 a:15
Thread name:Thread-1 a:16
Thread name:Thread-0 a:17
Thread name:Thread-1 a:18


这里原因不明，笔者曾尝试过在for里面每执行一次就输出相应的lock，都是一样的，但是，从输出结果就已经可以看见，其实已经是不同步的了


3.当修改发生在线程开始了一段时间之后，对同步没有影响

package com.ray.deepintothread.ch02.topic_24;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfStaticInnerClass3 {

	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			public void run() {
				MyService3.updateA();
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				MyService3.updateB();
			}
		});
		thread2.start();
	}
}

class MyService3 {

	private static int a = 0;

	private static Object lock = new Object();

	public static void updateA() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				if (i == 5) {//把对监视器的修改延时了
					lock = new Object();
				}
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void updateB() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

输出：

Thread name:Thread-0 a:0
Thread name:Thread-0 a:1
Thread name:Thread-0 a:2
Thread name:Thread-0 a:3
Thread name:Thread-0 a:4
Thread name:Thread-0 a:5
Thread name:Thread-0 a:6
Thread name:Thread-0 a:7
Thread name:Thread-0 a:8
Thread name:Thread-0 a:9
Thread name:Thread-1 a:10
Thread name:Thread-1 a:11
Thread name:Thread-1 a:12
Thread name:Thread-1 a:13
Thread name:Thread-1 a:14
Thread name:Thread-1 a:15
Thread name:Thread-1 a:16
Thread name:Thread-1 a:17
Thread name:Thread-1 a:18
Thread name:Thread-1 a:19


package com.ray.deepintothread.ch02.topic_24;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfStaticInnerClass4 {

	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					MyService4.updateA();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				MyService4.updateB();
			}
		});
		thread2.start();
	}
}

class MyService4 {

	private static int a = 0;

	private static Object lock = new Object();

	public static void updateA() throws InterruptedException {
		synchronized (lock) {
			Thread.sleep(300);//把对监视器的修改延时了
			lock = new Object();
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void updateB() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

输出：

Thread name:Thread-0 a:0
Thread name:Thread-0 a:1
Thread name:Thread-0 a:2
Thread name:Thread-0 a:3
Thread name:Thread-0 a:4
Thread name:Thread-0 a:5
Thread name:Thread-0 a:6
Thread name:Thread-0 a:7
Thread name:Thread-0 a:8
Thread name:Thread-0 a:9
Thread name:Thread-1 a:10
Thread name:Thread-1 a:11
Thread name:Thread-1 a:12
Thread name:Thread-1 a:13
Thread name:Thread-1 a:14
Thread name:Thread-1 a:15
Thread name:Thread-1 a:16
Thread name:Thread-1 a:17
Thread name:Thread-1 a:18
Thread name:Thread-1 a:19


4.修改监视器对象的属性，对同步没有影响

package com.ray.deepintothread.ch02.topic_24;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfStaticInnerClass5 {

	public static void main(String[] args) {
		MyService5 myService5 = new MyService5();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					myService5.updateA();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				myService5.updateB();
			}
		});
		thread2.start();
	}
}

class MyService5 {

	private static int a = 0;

	private static Monitor lock;

	public MyService5() {
		lock = new Monitor();
		lock.id = 1;
	}

	public void updateA() throws InterruptedException {
		synchronized (lock) {
			lock.id = 2;// 修改对象的属性
			Thread.sleep(300);
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public void updateB() {
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println("Thread name:" + Thread.currentThread().getName() + " a:" + a++);
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

class Monitor {
	public int id = 0;
}


输出：

Thread name:Thread-0 a:0
Thread name:Thread-0 a:1
Thread name:Thread-0 a:2
Thread name:Thread-0 a:3
Thread name:Thread-0 a:4
Thread name:Thread-0 a:5
Thread name:Thread-0 a:6
Thread name:Thread-0 a:7
Thread name:Thread-0 a:8
Thread name:Thread-0 a:9
Thread name:Thread-1 a:10
Thread name:Thread-1 a:11
Thread name:Thread-1 a:12
Thread name:Thread-1 a:13
Thread name:Thread-1 a:14
Thread name:Thread-1 a:15
Thread name:Thread-1 a:16
Thread name:Thread-1 a:17
Thread name:Thread-1 a:18
Thread name:Thread-1 a:19


总结：这一章节我们总结了几种修改监视器对同步的影响。


这一章节就到这里，谢谢

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

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


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


李灵晖
关注
专栏目录
Android 中catch(Exception e){ e.printStackTrace() ; }的原理
你的外祖父的博客
12-06 8829
catch(Exception e){ e.printStackTrace() ; } 当try语句中出现异常时，会执行catch中的语句，java运行时系统会自动将catch括号中的Exception e 初始化，也就是实例化Exception类型的对象，e是此对象引用名称，然后e（引用）会自动调用Exception类中指定的方法，也就出现了e.printStackTrace() ;。 prin...
从头认识多线程-目录
raylee2007的专栏
04-20 3156
第一章 回顾多线程基础1.1 多线程的创建1.2 共享变量与线程安全简介1.3 currentThread()1.4 isAlive()和Sleep()1.5 interrupt()和isInterrupt()1.6 迫使线程停止的方法-异常法1.7 迫使线程停止的方法-异常法的扩展（Sleep的Exception）1.8 迫使线程停止的方法-暴力Stop方法1.9 迫使线程停止的方法-retur
《Squid 中文权威指南》（上）-向译者彭勇华致敬！！！
alex_lov的专栏
09-03 1466
  第一章是Squid 的简介性描述。 1.1 Web 缓存 这节里需要明白3个概念： cache 命中 - 在squid 每次从它的缓存里满足HTTP 请求时发生。cache 命中率，是所有HTTP 请求中命中的比例。Web 缓存典型的cache 命中率在30%到60%之间。另一个相似的度量单位叫做字节命中率，描绘了cache 提供服务的数据容量（字节数）。 cache丢失 - 在squ
java面试
最新发布
qq_48711031的博客
03-11 627
可以利⽤Zookeeper的临时节点和watch机制来实现注册中⼼的⾃动注册和发现，另外Zookeeper中的数据都是存在内存中的，并且Zookeeper底层采⽤了nio，多线程模型，所以Zookeeper的性能也是⽐较⾼的，所以可以⽤来作为注册中⼼，但是如果考虑到注册中⼼应该是注册可⽤性的话，那么Zookeeper则不太合适，因为Zookeeper是CP的，它注重的是⼀致性，所以集群数据不⼀致时，集群将不可⽤，所以⽤Redis、Eureka、Nacos来作为注册中⼼将更合适。
【Linux C】GCC编译 && GDB调试 从入门到放弃 （gcc调试选项详解、gdb调试、条件断点、远程调试、脚本化调试）
热门推荐
风高秋月白，雨霁晚霞红
05-21 1万+
gcc和gdb从入门到放弃。
java面试题（八股文）
m0_59407102的博客
09-13 1097
此面试题内容较为基础，适用于中小厂的面试。
C++ Standard Library简介
03-10 998
C++ Standard Library是C++语言标准库，由C++官方提供并定义了一系列标准的类型、函数和模板（包括输入/输出、字符串处理、数学计算、容器、算法等）。C++ Standard Library是C++语言的基础，并且是所有C++开发人员都应该掌握的知识点。 对于C++ Standard Library的开源项目框架，网上有很多资源可以参考，比如：
Java面试题总结
weixin_44605543的博客
08-31 1237
1. Java基础 1.1 JDK和JRE的区别 ​ JDK是整个JAVA的核心，包括了Java运行环境JRE，一堆Java工具和Java基础的类库。通过JDK开发人员将源码文件(java文件)编译成字节码文件(class文件)。 JRE是Java运行环境，不含开发环境，即没有编译器和调试器。将class文件加载到内存准备运行 1.2 讲一讲Java内存的堆(heap)、栈(stack)和方法区(method) 栈：调用方法将在栈中开辟内存，称为入栈(压栈)。 栈内存存放基本类型值和引用数
人工智能-项目实践-多线程-断点续传与多线程下载.zip
01-04
在这个名为"人工智能-项目实践-多线程-断点续传与多线程下载.zip"的压缩包中，可能包含了一个使用Retrofit库实现的断点续传和多线程下载的项目实例。现在，我们将深入探讨这两个主题。 **断点续传** 断点续传是一...
人工智能-项目实践-多线程-Paxos算法的多线程实现.zip
01-04
3. **Multi-Paxos**：在实际应用中，通常会用多轮Paxos来简化流程，避免每次提案都需从头开始。 4. **Chubby锁服务**：Google基于Paxos实现的分布式锁服务，它在Paxos基础上进行了许多工程上的优化。 5. **...
商业编程-源码-点对点多线程断点续传软件《传圣》源代码.zip
06-22
点对点（P2P）多线程断点续传技术是互联网中一种高效的数据传输方式，尤其在大文件传输时表现出优越性。这个压缩包文件包含的是一个名为《传圣》的软件的源代码，这是一款专为商业环境设计的、支持多线程和断点续传...
从头认识多线程-1.9 迫使线程停止的方法-return法
raylee2007的专栏
04-17 2557
这一章节我们来讨论一下另一种停止线程的方法-return1.在主线程上面return，是把所有在运行的线程都停掉package com.ray.deepintothread.ch01.topic_9; public class StopByReturn { public static void main(String[] args) throws InterruptedException {
从头认识多线程-2.1 局部变量与实例变量的线程安全
raylee2007的专栏
04-21 8126
这一章节我们来讨论一下局部变量与实例变量的线程安全。1.结论局部变量线程安全的实例变量不是线程安全的2.代码清单package com.ray.deepintothread.ch02.topic_1; public class ThreadSafeOfLocalVariable { public static void main(String[] args) throws Interrupte
从头认识多线程-2.4 脏读（DirtyRead）
raylee2007的专栏
04-25 8019
这一章节我们来讨论一下脏读（DirtyRead）。1.为什么出现脏读？因为代码没有做同步，虽然set方法同步，但是由于get方法一般都会忘了，导致读的值是被写过的2.代码清单（1）由于程序没有同步，并且执行太快，导致脏读package com.ray.deepintothread.ch02.topic_4; public class DirtyRead { public static void
从头认识多线程-4.3 ThreadLocal使用时需要注意的地方
raylee2007的专栏
06-17 6340
4.3 这一章节我们来讨论一下关于ThreadLocal的使用的时候需要注意的地方ThreadLocal主要的使用是get、set、initialValue这几个方法，具体的使用我们这里不做介绍，下面只是举一些它使用的时候需要注意的地方。1.在get方法的时候出现nullpackage com.ray.deepintothread.ch04.topic_3;public class ThreadLo
从头认识多线程-2.14 由同步的synchronized (newobject()) 引起的异步现象和脏读
raylee2007的专栏
05-07 5558
这一章节我们来讨论一下由同步的synchronized (newobject()) 引起的异步现象。1.代码清单package com.ray.deepintothread.ch02.topic_14; /** * * @author RayLee * */ public class AsynchOfSynchWithUnSameObject { public static void
从头认识多线程-2.9 缓解同步方法的隐患-同步代码块
raylee2007的专栏
05-02 5404
这一章节我们来讨论一下缓解同步方法的隐患-同步代码块。1.思路：把同步方法，降低同步的粒度，同步到代码块2.根据上一章节的例子，我们把代码修改一下（1）第一种方法，把同步标记移到更新的那一栏里面去，一般来说大部分都是更新的时候需要同步数据package com.ray.deepintothread.ch02.topic_9; /** * 从头认识多线程-2.8 缓解同步方法的隐患-同步代码块
从头认识多线程-2.20 synchronized同步方法的无限等待与解决方法
raylee2007的专栏
05-15 5377
这一章节我们讨论一下synchronized同步方法的无限等待与解决方法。1.synchronized同步方法的无限等待package com.ray.deepintothread.ch02.topic_20; /** * * @author RayLee * */ public class InfiniteWait { public static void main(String[
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值