- 浏览: 1091241 次
文章分类
- 全部博客 (379)
- S2SH (16)
- stuts2 (0)
- java语言 (81)
- JSP (17)
- <html>元素 (11)
- javaweb (4)
- web容器 (3)
- ext (23)
- javaScript (48)
- ant (1)
- liferay (1)
- sql (9)
- css (42)
- 浏览器设置 (3)
- office_world (1)
- eclipse (4)
- 其它 (28)
- 操作系统 (5)
- android (6)
- Struts2 (11)
- RegEx (3)
- mysql (5)
- BigDATA (1)
- Node.js (1)
- Algorithm (10)
- Apache Spark (1)
- 数据库 (5)
- linux (2)
- git (1)
- Adobe (3)
- java语言,WebSocket (1)
- Maven (3)
- SHELL (1)
- XML (2)
- 数学 (2)
- Python (2)
- Java_mysql (1)
- ReactJS (6)
- 养生 (4)
- Docker (1)
- Protocols (3)
- java8 (2)
- 书籍 (1)
- Gradle (2)
- AngularJS (5)
- SpringMVC (2)
- SOAP (1)
- BootstrapCSS (1)
- HTTP协议 (1)
- OAuth2 (1)
最新评论
-
Lixh1986:
Java并发编程:自己动手写一把可重入锁https://blo ...
Java之多线程之Lock与Condition -
Lixh1986:
http://win.51apps.com.cn/https: ...
temp -
ztwsl:
不错,支持很好
HttpServletRequest和ServletRequest的区别 -
guodongkai:
谢谢您能将知识精华汇编总结,让初学者们从原理中学会和提高。
javaScript之function定义 -
kangwen23:
谢谢了,顶顶
struts2中的ValueStack学习
Java之线程同步与安全(Thread Synchronize & Safe)
一、问题背景
Java语言提供了多线程的功能。
多线程创建于相同的Object,多线程间共享Object的变量或属性。
但是,当线程对共享的数据进行读写时,会导致数据的不一致(data inconsistency)。
二、线程同步情景分析
数据不一致的原因是由数据操作的非原子性引起的。
即:更新任何属性或变量,非一步完成,而是需要三部:
1、读取现在的值。
2、进行必要的操作以得到要更新的值。
3、把更新的值写入到引用的变量或属性中。
来看一个简单的例子:
多个线程共享一个数据,并对其进行修改。
上述循环中,使用两个线程对 count 变量的值进行增加,每个线程各增加四次。
最后 count 的值应该是 8。但是在实际的多次运行中,它的值在 6,7,8 之间。
发生这种情况,即使 count++ 看起来是单原子操作,实际不是。
从而导致数据不一致。
三、Java中保证线程同步的方法
为了在多线程运行环境中确保数据的一致,Java提供了一些方法。
下面是主要的几种:
1、使用 synchronized 关键字(最广泛使用)
2、使用 java.util.concurrent.atomic 包下的原子操作包装类。
例如: AtomicInteger
3、使用 java.util.concurrent.locks 包下的锁类
4、使用 线程安全的集合类。
例如: ConcurrentHashMap
5、使用 volatile 关键字确保读的一致性。(不能确保写一致)
确保每个线程是从内存中读取值,而不是线程缓存中。
三·一 使用 synchronized 关键字
JVM 可以确保被 synchronized 修饰的代码块每次只能被一个线程访问执行。
内部通过锁住一个对象或类来实现。
1、synchronized 可以在被锁定的资源或未被锁定的资源情况下工作。
但是,在任何线程执行 synchronized 代码块之前,
它需要首先获取这个对象的锁才可以执行。
而线程执行非 synchronized 代码块不需要获取对象的锁。
当然,线程在代码块执行完毕后,需要释放该锁。
这样其它处于等待状态的线程可以获取对象的锁以执行。
2、synchronized 的使用方式有两种:
1)用在类方法的声明上。使整个方法成为 synchronized 方法。
此时会锁定 Object (实例),如果是静态方法则锁类。
为了提高运行性能,请尽量少使用该策略。
2)单独使用。形成一个 synchronized 代码块。
只锁定方法中需要锁定的代码块。
此时,需要提供资源,以从该资源中取得锁。
资源可以是 ABC.class 或 类的一个属性。
synchronized(this) 会锁定当前整个实例,
即同时获取了当前实例的锁 + 实例所有属性的锁。
注意:为了提高执行性能,被锁的对象应该是最小范围的。
例如在一个类中有多个 synchronized 的代码块,其中
一块锁定了整个实例。则其它代码块则不能被其它线程执行。
3、synchronized 是以降低性能为代价的(本来可以并行执行,先只能串行执行)。
所以非必需,不要用。
4、synchronized 只在同一个 JVM 中是有效的。
5、synchronized 会造成[死锁]现象。
synchronized 代码块同时锁定多个对象。多个线程互相等待其它线程释放对象的锁。
6、synchronized 不能用于 构造方法 和 局部变量。
7、synchronized 锁定的实例,应该避免是 常量池 中的对象。
这些常量池中的对象可能被其它 synchronized 代码块引用。例如:String pool
8、synchronized 通常锁定一个虚设的 private 的类属性,对代码块进行锁定。
因为 private 的引用指向的实例始终是一个。不会变。
下面的改进使 count 属性线程安全的代码:
让我们看一些 synchronized 的例子,看看我们能学到什么:
例子一:
如果能够拿到 MyObject 的实例,并且在锁定该实例无限长的时间。
其它代码则无法执行该实例的方法。尤其在单例模式中。
例子二:
更有甚者:
输出结果:
Lock class instance!
M: Hello, Word
分析:
C: Hello, Word
这一句没有输出,因为 MyObject.class 对象被其它 Lock 锁定
根据结果可以看出:
要锁定的对象可以是类(class),也可以是类的实例(instance)。
但是类和类的实例在锁的问题上不相关,也没有权限上你大我小的隶属关系。
锁对象和锁类的区别?
synchronized(X.class)
使用 class类 所为锁定类, 那是因为只有一个 class 类在 JVM 中被 classLoader 加载。
如果一个线程要执行该代码块,必须拥有 class 类的锁。
此时只能有一个线程在执行该代码块。
synchronized(this)
使用类的实例为锁定对象。
如果一个线程要执行该代码块,只需拥有实例的锁即可。
此时可以有多个线程在执行该代码块。
例子三:
注意:
lock 属性是 public 的。通过替换它指向引用的对象,多个线程就可以执行 synchronized 块的代码。
类似情况:private 的属性,但是有 public 的 set() 方法。
例子四:
注意:没有 static 关键字,则不等价。
例子五:
输出:
Time taken= 1501
[1:t1, 2:t2, 3:t2:t3, 4:t1, 5:t1:t2, 6:t3:t2]
加上同步锁:
输出:
Time taken= 1502
[1:t1:t2:t3, 2:t2:t1:t3, 3:t1:t2:t3, 4:t1:t2:t3, 5:t2:t1:t3, 6:t1:t2:t3]
继续阅读:
使用 java.util.concurrent.lock.Lock 实现线程同步
-
转载请注明,
原文出处:http://lixh1986.iteye.com/blog/2351243
-
引用:
http://www.journaldev.com/1061/thread-safety-in-java
一、问题背景
Java语言提供了多线程的功能。
多线程创建于相同的Object,多线程间共享Object的变量或属性。
但是,当线程对共享的数据进行读写时,会导致数据的不一致(data inconsistency)。
二、线程同步情景分析
数据不一致的原因是由数据操作的非原子性引起的。
即:更新任何属性或变量,非一步完成,而是需要三部:
1、读取现在的值。
2、进行必要的操作以得到要更新的值。
3、把更新的值写入到引用的变量或属性中。
来看一个简单的例子:
多个线程共享一个数据,并对其进行修改。
public class ThreadSafety { public static void main(String[] args) throws InterruptedException { ProcessingThread pt = new ProcessingThread(); Thread t1 = new Thread(pt, "t1"); t1.start(); Thread t2 = new Thread(pt, "t2"); t2.start(); //wait for threads to finish processing t1.join(); t2.join(); System.out.println("Processing count="+pt.getCount()); } } class ProcessingThread implements Runnable{ private int count; @Override public void run() { for(int i=1; i < 5; i++){ processSomething(i); count++; } } public int getCount() { return this.count; } private void processSomething(int i) { // processing some job try { Thread.sleep(i*1000); } catch (InterruptedException e) { e.printStackTrace(); } } }
上述循环中,使用两个线程对 count 变量的值进行增加,每个线程各增加四次。
最后 count 的值应该是 8。但是在实际的多次运行中,它的值在 6,7,8 之间。
发生这种情况,即使 count++ 看起来是单原子操作,实际不是。
从而导致数据不一致。
三、Java中保证线程同步的方法
为了在多线程运行环境中确保数据的一致,Java提供了一些方法。
下面是主要的几种:
1、使用 synchronized 关键字(最广泛使用)
2、使用 java.util.concurrent.atomic 包下的原子操作包装类。
例如: AtomicInteger
3、使用 java.util.concurrent.locks 包下的锁类
4、使用 线程安全的集合类。
例如: ConcurrentHashMap
5、使用 volatile 关键字确保读的一致性。(不能确保写一致)
确保每个线程是从内存中读取值,而不是线程缓存中。
三·一 使用 synchronized 关键字
JVM 可以确保被 synchronized 修饰的代码块每次只能被一个线程访问执行。
内部通过锁住一个对象或类来实现。
1、synchronized 可以在被锁定的资源或未被锁定的资源情况下工作。
但是,在任何线程执行 synchronized 代码块之前,
它需要首先获取这个对象的锁才可以执行。
而线程执行非 synchronized 代码块不需要获取对象的锁。
当然,线程在代码块执行完毕后,需要释放该锁。
这样其它处于等待状态的线程可以获取对象的锁以执行。
2、synchronized 的使用方式有两种:
1)用在类方法的声明上。使整个方法成为 synchronized 方法。
此时会锁定 Object (实例),如果是静态方法则锁类。
为了提高运行性能,请尽量少使用该策略。
2)单独使用。形成一个 synchronized 代码块。
只锁定方法中需要锁定的代码块。
此时,需要提供资源,以从该资源中取得锁。
资源可以是 ABC.class 或 类的一个属性。
synchronized(this) 会锁定当前整个实例,
即同时获取了当前实例的锁 + 实例所有属性的锁。
注意:为了提高执行性能,被锁的对象应该是最小范围的。
例如在一个类中有多个 synchronized 的代码块,其中
一块锁定了整个实例。则其它代码块则不能被其它线程执行。
3、synchronized 是以降低性能为代价的(本来可以并行执行,先只能串行执行)。
所以非必需,不要用。
4、synchronized 只在同一个 JVM 中是有效的。
5、synchronized 会造成[死锁]现象。
synchronized 代码块同时锁定多个对象。多个线程互相等待其它线程释放对象的锁。
6、synchronized 不能用于 构造方法 和 局部变量。
7、synchronized 锁定的实例,应该避免是 常量池 中的对象。
这些常量池中的对象可能被其它 synchronized 代码块引用。例如:String pool
8、synchronized 通常锁定一个虚设的 private 的类属性,对代码块进行锁定。
因为 private 的引用指向的实例始终是一个。不会变。
下面的改进使 count 属性线程安全的代码:
//dummy object variable for synchronization private Object mutex=new Object(); //using synchronized block to read, increment and update count value synchronously synchronized (mutex) { count++; }
让我们看一些 synchronized 的例子,看看我们能学到什么:
例子一:
public class MyObject { // Locks on the object's monitor public synchronized void doSomething() { // ... } } public class Hack{ public static void main(String[] args){ // Hackers code MyObject myObject = Factory.getMyObject(); synchronized (myObject) { while (true) { // Indefinitely delay myObject Thread.sleep(Integer.MAX_VALUE); } } } }
如果能够拿到 MyObject 的实例,并且在锁定该实例无限长的时间。
其它代码则无法执行该实例的方法。尤其在单例模式中。
例子二:
更有甚者:
package com.gentleman.sychronized; public class Hack { public static void main(String[] args) throws Exception{ new Thread(new R1()).start(); Thread.sleep(1000); new Thread(new R2()).start(); new Thread(new R3()).start(); } } class MyObject { public void sayHello(){ synchronized(MyObject.class){ System.out.println("C: Hello, Word"); } } public synchronized void sayHello2(){ System.out.println("M: Hello, Word"); } } class R1 implements Runnable{ @Override public void run(){ synchronized (MyObject.class) { System.out.println("Lock class instance!"); while (true) { try { Thread.sleep(Integer.MAX_VALUE); } catch (InterruptedException e) { e.printStackTrace(); } } } } } class R2 implements Runnable{ @Override public void run() { MyObject myObject = new MyObject(); myObject.sayHello(); } } class R3 implements Runnable{ @Override public void run() { MyObject myObject = new MyObject(); myObject.sayHello2(); } }
输出结果:
Lock class instance!
M: Hello, Word
分析:
C: Hello, Word
这一句没有输出,因为 MyObject.class 对象被其它 Lock 锁定
根据结果可以看出:
要锁定的对象可以是类(class),也可以是类的实例(instance)。
但是类和类的实例在锁的问题上不相关,也没有权限上你大我小的隶属关系。
锁对象和锁类的区别?
synchronized(X.class)
使用 class类 所为锁定类, 那是因为只有一个 class 类在 JVM 中被 classLoader 加载。
如果一个线程要执行该代码块,必须拥有 class 类的锁。
此时只能有一个线程在执行该代码块。
synchronized(this)
使用类的实例为锁定对象。
如果一个线程要执行该代码块,只需拥有实例的锁即可。
此时可以有多个线程在执行该代码块。
例子三:
public class MyObject { public Object lock = new Object(); public void doSomething() { synchronized (lock) { // ... } } } //untrusted code MyObject myObject = new MyObject(); //change the lock Object reference myObject.lock = new Object();
注意:
lock 属性是 public 的。通过替换它指向引用的对象,多个线程就可以执行 synchronized 块的代码。
类似情况:private 的属性,但是有 public 的 set() 方法。
例子四:
static void myMethod() { synchronized(MyClass.class) { //code } } // 等价于: static synchronized void myMethod() { //code }
注意:没有 static 关键字,则不等价。
void myMethod() { synchronized(this) { //code } } // 等价于: synchronized void myMethod() { //code }
例子五:
import java.util.Arrays; public class T { public static void main(String[] args) throws InterruptedException { String[] arr = {"1","2","3","4","5","6"}; HashMapProcessor hmp = new HashMapProcessor(arr); Thread t1=new Thread(hmp, "t1"); Thread t2=new Thread(hmp, "t2"); Thread t3=new Thread(hmp, "t3"); long start = System.currentTimeMillis(); //start all the threads t1.start();t2.start();t3.start(); //wait for threads to finish t1.join();t2.join();t3.join(); System.out.println("Time taken= "+(System.currentTimeMillis()-start)); //check the shared variable value now System.out.println(Arrays.asList(hmp.getMap())); } } class HashMapProcessor implements Runnable{ private String[] strArr = null; public HashMapProcessor(String[] m){ this.strArr=m; } @Override public void run() { for(int i=0; i < strArr.length; i++){ processSomething(i); addThreadName( i, Thread.currentThread().getName()); } } private void addThreadName(int i, String name) { strArr[i] = strArr[i] +":"+name; } private void processSomething(int index) { // processing some job try { Thread.sleep(index * 100); } catch (InterruptedException e) { e.printStackTrace(); } } public String[] getMap() { return strArr; } }
输出:
Time taken= 1501
[1:t1, 2:t2, 3:t2:t3, 4:t1, 5:t1:t2, 6:t3:t2]
加上同步锁:
private Object lock = new Object(); private void addThreadName2(int i, String name) { synchronized(lock){ strArr[i] = strArr[i] +":"+name; } }
输出:
Time taken= 1502
[1:t1:t2:t3, 2:t2:t1:t3, 3:t1:t2:t3, 4:t1:t2:t3, 5:t2:t1:t3, 6:t1:t2:t3]
继续阅读:
使用 java.util.concurrent.lock.Lock 实现线程同步
-
转载请注明,
原文出处:http://lixh1986.iteye.com/blog/2351243
-
引用:
http://www.journaldev.com/1061/thread-safety-in-java
发表评论
-
java 将文件夹所有的文件合并到指定的文件夹下
2020-06-30 19:17 978场景:将文件夹所有的文件合并到指定的文件夹下 另外:如果想效 ... -
多线程-线程池的四种创建方式
2020-04-01 18:38 410多线程-线程池的四种创建方式 https://blog.cs ... -
Java基础之:nio
2019-11-13 15:38 414一、理论讲解: 史上最强Java NIO入门:担心从入门到放弃 ... -
Java 分布式之:RPC 基本概念
2019-11-13 15:07 402转载: https://www.jianshu.com/p/ ... -
Java之 volatile 关键字原理详解
2019-11-07 15:36 444一、什么是 volatile ? ... -
POI实现excell批注背景图片(仿html浮窗显示图片)
2019-10-21 08:17 602POI实现excell批注背景图片(仿html浮窗显示图片) ... -
Java之设计模式之 Observer 观察者
2019-07-04 17:21 972观察者设计模式 Java 已经实现了该模式,并且提供了使用类 ... -
HashMap, LinkedHashMap and TreeMap
2019-03-01 11:04 625https://stackoverflow.com/a/177 ... -
Java lib 操作 excel 插入图片
2019-01-19 12:46 839https://poi.apache.org/componen ... -
数据库连接池C3P0
2018-05-29 16:50 811一、名字的由来 很多 ... -
Java8之集合(Collection)遍历 forEach()、stream()
2018-05-29 14:39 20660package java8.collections; ... -
Junit Vs main on "java.util.concurrent.Executors"
2017-11-10 16:44 734Same code with different result ... -
Java之大数据学习路线
2017-11-03 10:08 5673三个月大数据研发学习 ... -
Java中创建对象的5种方式
2017-10-26 14:21 806一、Java之5种创建对象的方式 ————————————— ... -
Log4j和Slf4j的比较
2017-06-23 12:41 1361一直搞不清 Log4j 和 SLF4j 的关系。今天才若有所 ... -
Java之Java7新特性之try资源句式
2017-04-20 14:58 5340Java之Java7新特性之try资源句式 一、【try资源 ... -
Java之 java.util.concurrent 包之ExecutorService之submit () 之 Future
2017-03-04 21:27 3773一、如何使用 ExecutorService.submit() ... -
Java之 java.util.concurrent 包之Executor与ExecutorService
2017-03-04 21:18 2645一、问题: execute() 与 submit() 的区别? ... -
JAVAEE之单用户登录
2017-02-05 11:55 1032单用户登录是系统中数据一直性的解决方案之一。 问题背景: 试 ... -
Java之多线程之线程池之线程重复使用
2017-02-04 13:33 5523一、问题背景 在使用多线程时,如果要开启一个任务,则就需要新 ...
相关推荐
当多个线程同时读写同一份共享资源的时候,可能会引起冲突。这时候,我们需要引入线程“同步”机制,即各位线程之间要有个先来后到,不能一窝蜂挤上去抢作一团。
delphi vcl线程同步synchronize
关于线程同步 synchronize,需要牢牢记住的第一点是:线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。
主要介绍了Java synchronize线程安全测试,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
专门用来比较和同步目录的程序,可用于源程序管理,如果比较的结果有不同的时候,可以用新的文件覆盖过旧的文件,达到同步更新的目的,也可以自己选择决定是否更新。Synchronize It!还有其他特点如下: 1.可以自订...
懒汉式—线程安全:加上synchronize之类保证线程安全的基础上的懒汉模式,相对性能很低,大部分时间并不需要同步 饿汉方式。指全局的单例实例在类装载时构建。 [2] 双检锁式。在懒汉式基础上利用synchronize关键字和...
本代码介绍了如何给线程传递参数,以及用参数在主线程中显示数据
它提供了Thread/Runnable/ThreadGroup等一系列封装的类和接口,让程序员可以高效的开发Java多线程应用。为了实现同步,Java提供了synchronize关键字以及object的wait()/notify()机制,可是在简单易用的背后,应藏着...
Java对象锁和类锁全面解析(多线程synchronized关键字)编程开发技术共14页.pdf.zip
Synchronize的几种实现 Synchronize有三种实现。 同步方法,修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁 静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁 修饰代码块...
多线程,用什么关键字修饰同步方法?stop()和suspend()方法为何不推荐使用? 59.使用socket建立客户端与服务器的通信的过程 60.JAVA语言国际化应用,Locale类,Unicode 61.描述反射机制的作用 62.如何读写一个...
最大的不同是,Hashtable的方法是Synchronize的,而HashMap不是,在多个线程访问Hashtable时,不需要自己为它的方法实现同步,而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概...
主要介绍了Java 中synchronize函数的实例详解的相关资料,希望通过本文能帮助到大家理解使用synchronize函数的使用方法,需要的朋友可以参考下
2.need_synchronize_files.txt:待同步文件名列表,直接从svn提测信息复制过来的 3.config.properites为工程运行配置文件,NEED_SYN_FILE_PATH:为待同步文件名列表的路径, SRC_PATH:源路径,DEST_PATH:目的路径...
Delphi中有一个线程类TThread是用来实现多线程编程的,这个绝大多数Delphi书藉都有说到,但基本上都是对TThread类的几个成员作一简单介绍,再说明一下Execute的实现和Synchronize的用法就完了。然而这并不是多线程编...
最简单的多线程实例,适合初接触多线程的人员参考使用,BCB多线程实例。
HashMap和Hashtable的区别。 HashMap是Hashtable的轻量级实现(非线程安全的实现) ...现同步,而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概一样,所 以性能不会有很大的差异。
使用Win32 Event对象的线程同步。
最大的不同是,Hashtable的方法是Synchronize的,而HashMap不是,在多个线程访问Hashtable时,不需要自己为它的方法实现同步,而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概...