- 浏览: 81731 次
- 性别:
- 来自: 厦门
文章分类
最新评论
-
huang_yong:
也可以使用loadOnStartup=0,这样是不是比1更早初 ...
loadOnStartup -
elfasd:
good,thank you !
解决gson格式化日期不规范导致javascript无法解析日期的问题 -
joe243634401:
coollzh 写道我也是这么写的,为甚么会出现404找不到的 ...
loadOnStartup -
coollzh:
我也是这么写的,为甚么会出现404找不到的现象,用web.xm ...
loadOnStartup
Java良好的支持多线程。使用java,我们可以很轻松的编程一个多线程程序。但是使用多线程可能会引起并发访问的问题。synchronized和ThreadLocal都是用来解决多线程并发访问的问题。大家可能对synchronized较为熟悉,而对ThreadLocal就要陌生得多了。
并发问题。当一个对象被两个线程同时访问时,可能有一个线程会得到不可预期的结果。
一个简单的java类Studnet
private int age=0;
public int getAge() ...{
return this.age;
}
public void setAge(int age) ...{
this.age = age;
}
}
一个多线程类ThreadDemo.
这个类有一个Student的私有变量,在run方法中,它随机产生一个整数。然后设置到student变量中,从student中读取设置后的值。然后睡眠5秒钟,最后再次读student的age值。
代码
Student student = new Student();
public static void main(String[] agrs) ...{
ThreadDemo td = new ThreadDemo();
Thread t1 = new Thread(td,"a");
Thread t2 = new Thread(td,"b");
t1.start();
t2.start();
}
/**//* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
public void run() ...{
accessStudent();
}
public void accessStudent() ...{
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName+" is running!");
// System.out.println("first read age is:"+this.student.getAge());
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread "+currentThreadName +" set age to:"+age);
this.student.setAge(age);
System.out.println("thread "+currentThreadName+" first read age is:"+this.student.getAge());
try ...{
Thread.sleep(5000);
}
catch(InterruptedException ex) ...{
ex.printStackTrace();
}
System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
}
}
运行这个程序,屏幕输出如下:
a is running!
b is running!
thread b set age to:33
thread b first read age is:33
thread a set age to:81
thread a first read age is:81
thread b second read age is:81
thread a second read age is:81
需要注意的是,线程a在同一个方法中,第一次读取student的age值与第二次读取值不一致。这就是出现了并发问题。
synchronized
上面的例子,我们模似了一个并发问题。Java提供了同步机制来解决并发问题。synchonzied关键字可以用来同步变量,方法,甚至同步一个代码块。
使用了同步后,一个线程正在访问同步对象时,另外一个线程必须等待。
Synchronized同步方法
现在我们可以对accessStudent方法实施同步。
public synchronized void accessStudent()
再次运行程序,屏幕输出如下:
a is running!
thread a set age to:49
thread a first read age is:49
thread a second read age is:49
b is running!
thread b set age to:17
thread b first read age is:17
thread b second read age is:17
加上了同步后,线程b必须等待线程a执行完毕后,线程b才开始执行。
对方法进行同步的代价是非常昂贵的。特别是当被同步的方法执行一个冗长的操作。这个方法执行会花费很长的时间,对这样的方法进行同步可能会使系统性能成数量级的下降。
Synchronized同步块
在accessStudent方法中,我们真实需要保护的是student变量,所以我们可以进行一个更细粒度的加锁。我们仅仅对student相关的代码块进行同步。
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread "+currentThreadName +" set age to:"+age);
this.student.setAge(age);
System.out.println("thread "+currentThreadName+" first read age is:"+this.student.getAge());
try ...{
Thread.sleep(5000);
}
catch(InterruptedException ex) ...{
ex.printStackTrace();
}
}
运行方法后,屏幕输出:
a is running!
thread a set age to:18
thread a first read age is:18
b is running!
thread a second read age is:18
thread b set age to:62
thread b first read age is:62
thread b second read age is:62
需要特别注意这个输出结果。
这个执行过程比上面的方法同步要快得多了。
只有对student进行访问的代码是同步的,而其它与部份代码却是异步的了。而student的值并没有被错误的修改。如果是在一个真实的系统中,accessStudent方法的操作又比较耗时的情况下。使用同步的速度几乎与没有同步一样快。
使用同步锁
稍微把上面的例子改一下,在ThreadDemo中有一个私有变量count,。
private int count=0;
在accessStudent()中, 线程每访问一次,count都自加一次, 用来记数线程访问的次数。
System.out.println(currentThreadName+" is running!");
try ...{
this.count++;
Thread.sleep(5000);
}catch(InterruptedException ex) ...{
ex.printStackTrace();
}
System.out.println("thread "+currentThreadName+" read count:"+this.count);
synchronized(this) ...{
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread "+currentThreadName +" set age to:"+age);
this.student.setAge(age);
System.out.println("thread "+currentThreadName+" first read age is:"+this.student.getAge());
try ...{
Thread.sleep(5000);
}
catch(InterruptedException ex) ...{
ex.printStackTrace();
}
}
System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
a is running!
b is running!
thread a read count:2
thread a set age to:49
thread a first read age is:49
thread b read count:2
thread a second read age is:49
thread b set age to:7
thread b first read age is:7
thread b second read age is:7
我们仍然对student对象以synchronized(this)操作进行同步。
我们需要在两个线程中共享count失败。
所以仍然需要对count的访问进行同步操作。
try ...{
this.count++;
Thread.sleep(5000);
}catch(InterruptedException ex) ...{
ex.printStackTrace();
}
}
System.out.println("thread "+currentThreadName+" read count:"+this.count);
synchronized(this) ...{
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread "+currentThreadName +" set age to:"+age);
this.student.setAge(age);
System.out.println("thread "+currentThreadName+" first read age is:"+this.student.getAge());
try ...{
Thread.sleep(5000);
}
catch(InterruptedException ex) ...{
ex.printStackTrace();
}
}
System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
long endTime = System.currentTimeMillis();
long spendTime = endTime - startTime;
System.out.println("花费时间:"+spendTime +"毫秒");
a is running!
b is running!
thread a read count:1
thread a set age to:97
thread a first read age is:97
thread a second read age is:97
花费时间:10015毫秒
thread b read count:2
thread b set age to:47
thread b first read age is:47
thread b second read age is:47
花费时间:20124毫秒
我们在同一个方法中,多次使用synchronized(this)进行加锁。有可能会导致太多额外的等待。
应该使用不同的对象锁进行同步。
设置两个锁对象,分别用于student和count的访问加锁。
private Object countLock = new Object();
accessStudent()方法如下:
long startTime = System.currentTimeMillis();
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName+" is running!");
// System.out.println("first read age is:"+this.student.getAge());
synchronized(countLock) ...{
try ...{
this.count++;
Thread.sleep(5000);
}catch(InterruptedException ex) ...{
ex.printStackTrace();
}
}
System.out.println("thread "+currentThreadName+" read count:"+this.count);
synchronized(studentLock) ...{
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread "+currentThreadName +" set age to:"+age);
this.student.setAge(age);
System.out.println("thread "+currentThreadName+" first read age is:"+this.student.getAge());
try ...{
Thread.sleep(5000);
}
catch(InterruptedException ex) ...{
ex.printStackTrace();
}
}
System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
long endTime = System.currentTimeMillis();
long spendTime = endTime - startTime;
System.out.println("花费时间:"+spendTime +"毫秒");
这样对count和student加上了两把不同的锁。
运行程序后,屏幕输出:
a is running!
b is running!
thread a read count:1
thread a set age to:48
thread a first read age is:48
thread a second read age is:48
花费时间:10016毫秒
thread b read count:2
thread b set age to:68
thread b first read age is:68
thread b second read age is:68
花费时间:20046毫秒
与两次使用synchronized(this)相比,使用不同的对象锁,在性能上可以得到更大的提升。
由此可见synchronized是实现java的同步机制。同步机制是为了实现同步多线程对相同资源的并发访问控制。保证多线程之间的通信。
可见,同步的主要目的是保证多线程间的数据共享。同步会带来巨大的性能开销,所以同步操作应该是细粒度的。如果同步使用得当,带来的性能开销是微不足道的。使用同步真正的风险是复杂性和可能破坏资源安全,而不是性能。
ThreadLocal
由上面可以知道,使用同步是非常复杂的。并且同步会带来性能的降低。Java提供了另外的一种方式,通过ThreadLocal可以很容易的编写多线程程序。从字面上理解,很容易会把ThreadLocal误解为一个线程的本地变量。其它ThreadLocal并不是代表当前线程,ThreadLocal其实是采用哈希表的方式来为每个线程都提供一个变量的副本。从而保证各个线程间数据安全。每个线程的数据不会被另外线程访问和破坏。
我们把第一个例子用ThreadLocal来实现,但是我们需要些许改变。
Student并不是一个私有变量了,而是需要封装在一个ThreadLocal对象中去。调用ThreadLocal的set方法,ThreadLocal会为每一个线程都保持一份Student变量的副本。所以对student的读取操作都是通过ThreadLocal来进行的。
Student student = (Student)studentLocal.get();
if(student == null) ...{
student = new Student();
studentLocal.set(student);
}
return student;
}
protected void setStudent(Student student) ...{
studentLocal.set(student);
}
Student student = getStudent();
student.setAge(age);
accessStudent()方法中无需要任何同步代码。
完整的代码清单如下:
TreadLocalDemo.java
private final static ThreadLocal studentLocal = new ThreadLocal();
public static void main(String[] agrs) ...{
TreadLocalDemo td = new TreadLocalDemo();
Thread t1 = new Thread(td,"a");
Thread t2 = new Thread(td,"b");
t1.start();
t2.start();
}
/**//* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
public void run() ...{
accessStudent();
}
public void accessStudent() ...{
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName+" is running!");
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread "+currentThreadName +" set age to:"+age);
Student student = getStudent();
student.setAge(age);
System.out.println("thread "+currentThreadName+" first read age is:"+student.getAge());
try ...{
Thread.sleep(5000);
}
catch(InterruptedException ex) ...{
ex.printStackTrace();
}
System.out.println("thread "+currentThreadName +" second read age is:"+student.getAge());
}
protected Student getStudent() ...{
Student student = (Student)studentLocal.get();
if(student == null) ...{
student = new Student();
studentLocal.set(student);
}
return student;
}
protected void setStudent(Student student) ...{
studentLocal.set(student);
}
}
b is running!
thread b set age to:0
thread b first read age is:0
a is running!
thread a set age to:17
thread a first read age is:17
thread b second read age is:0
thread a second read age is:17
可见,使用ThreadLocal后,我们不需要任何同步代码,却能够保证我们线程间数据的安全。
而且,ThreadLocal的使用也非常的简单。
我们仅仅需要使用它提供的两个方法
void set(Object obj) 设置当前线程的变量的副本的值。
Object get() 返回当前线程的变量副本
另外ThreadLocal还有一个protected的initialValue()方法。返回变量副本在当前线程的初始值。默认为null
ThreadLocal是怎么做到为每个线程都维护一个变量的副本的呢?
我们可以猜测到ThreadLocal的一个简单实现
...{
private Map values = Collections.synchronizedMap(new HashMap());
public Object get()
...{
Thread curThread = Thread.currentThread();
Object o = values.get(curThread);
if (o == null && !values.containsKey(curThread))
...{
o = initialValue();
values.put(curThread, o);
}
return o;
}
public void set(Object newValue)
...{
values.put(Thread.currentThread(), newValue);
}
public Object initialValue()
...{
return null;
}
}
Synchronized还是ThreadLocal?
ThreadLocal以空间换取时间,提供了一种非常简便的多线程实现方式。因为多个线程并发访问无需进行等待,所以使用ThreadLocal会获得更大的性能。虽然使用ThreadLocal会带来更多的内存开销,但这点开销是微不足道的。因为保存在ThreadLocal中的对象,通常都是比较小的对象。另外使用ThreadLocal不能使用原子类型,只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。
ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制,使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本,使得每个线程在某一时间访问到的并不是同一个对象,这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反,它用于在多个线程间通信时能够获得数据共享。
Synchronized用于线程间的数据共享,而ThreadLocal则用于线程间的数据隔离。
当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制,比ThreadLocal更加复杂。
发表评论
-
验证数据库连接,ip端口号连接状态
2011-12-06 10:02 975server1=10.10.10.91:9001 serve ... -
构造函数
2011-11-14 09:16 780缺省构造函数的问题:b ... -
加载数据库驱动Class.forName
2011-11-04 14:57 826使用JDBC时,我们都会很自然得使用下列语句: java ... -
读取后缀为properties文件
2011-11-02 16:47 841public class GetCfg { private s ... -
通过线程去实现项目启动后每隔段时间去扫描数据库
2011-11-02 16:37 953<servlet-name>DataSyn&l ... -
java调用存储过程
2011-10-31 09:37 857**********************存储过 ...
相关推荐
Synchronized与ThreadLocal
ThreadLocal一般称为线程本地变量,它是一种特殊的线程绑定机制,将变量与线程绑定在一起,为每一个线程维护一个独立的变量副本。通过ThreadLocal可以将对象的可见范围限制在同一个线程内。 跳出误区 需要...
你还在用synchronized?线程安全相关知识深入剖析
Java多线程技术思维导图,覆盖全面,可用作学习指导和查缺补漏,十分高效。...涵盖线程中断、线程状态、线程间通信,并发容器、ThreadLocal、Synchronized、CountDownLatch、CyclicBarrier等内容。
synchronized关键字不属于方法特征签名的一部分,所以可以在覆盖方法的时候加上去。也就是说,在父类的方法声明上可以没有synchronized关键字,而在子类覆盖该方法时加上synchronized关键字。 注意:使用...
2、可重入锁与 Synchronized 的其他特性 3、ThreadLocal 的底层实现与使用 4、ReentrantLock底层实现和如何使用 5、Condition源码分析 6、ReentrantReadWriteLock底层实现原理 7、并发工具类CountDownLatch 、...
主要介绍了Java中的线程同步与ThreadLocal无锁化线程封闭实现,Synchronized关键字与ThreadLocal变量的使用是Java中线程控制的基础,需要的朋友可以参考下
主要介绍了Java多线程编程中易混淆的3个关键字总结,本文总结了、volatile、ThreadLocal、synchronized等3个关键字,对这几个容易混淆概念的关键字分别做了讲解,需要的朋友可以参考下
多线程相关的(具体包括Lock synchronized Join ThreadLocal Executors CountDownLatch等)一些demo。
2.3 线程本地存储(Java.lang.ThreadLocal) 15 2.4 线程阻塞 17 2.4.1 调用sleep(millisecond)使任务进入休眠状态 17 2.4.2 等待输出与输入 17 2.4.3 对象锁不可用 17 2.4.4 通过wait()使线程挂起。 17 2.5 线程...
java 学习整理文档 Spring框架并...使用ThreadLocal ,在类中定义一个ThreadLocal成员变量,将需要的可变成员变量保存在 ThreadLocal 中(以空间换时间”),为每一个线程都提供了一份变量,因此可以同时访问而互不影响
java并发编程 基础知识,守护线程与线程, 并行和并发有什么区别? 什么是上下文切换? 线程和进程区别 什么是线程和进程? 创建线程有哪几种方式?,如何避免线程死锁 ...ThreadLocal内存泄漏分析与
ThreadLocal 使用及实现原理.mp4 并发工具类CountDownLatch详解.mp4 并发工具类CyclicBarrier 详解.mp4 并发工具类Semaphore详解.mp4 并发工具类Exchanger详解.mp4 CountDownLatch,CyclicBarrier,Semaphore源码解析....
线程创建、Synchronized和Reentrantlock锁的使用、线程安全问题演示、Condition的应用、CountDownLatch的应用、Cyclicbarrier的应用、Semaphore的应用、线程池的应用、Completablefuture的应用、手写阻塞队列、fork...
threadLocal 为每个线程保存一个副本 类似于一个以线程id为key的map 不可变对象状态 final 关键共享资源上互斥,变并发为串行即同步 锁 分类 显示锁 Lock Lock是个接口 实现类 ReentrantLock 可重入锁...
4.彻底理解synchronized 5.彻底理解volatile 6.你以为你真的了解final吗? 7.三大性质总结:原子性、可见性以及有序性 8.初识Lock与AbstractQueuedSynchronizer(AQS) 9.深入理解AbstractQueuedSynchronizer(AQS) 10....
synchronized在静态方法和普通方法的区别。 怎么实现所有线程在等待某个事件的发生才会去执行。 CAS。 Hashtable是怎么加锁的。 HashMap的并发问题。 ConcurrenHashMap 介绍。 AQS。 如何检测死锁,怎么预防死锁。 ...
synchronized在静态方法和普通方法的区别。 怎么实现所有线程在等待某个事件的发生才会去执行。 CAS。 Hashtable是怎么加锁的。 HashMap的并发问题。 ConcurrenHashMap 介绍。 AQS。 如何检测死锁,怎么预防死锁。 ...
目录: 基础概念 造成线程不安全的条件 变量种类与线程安全 如何避免线程不安全 synchronized关键字使用和原理 jdk多线程并发包 THREADLOCAL 测试工程
BATJ面试题汇总及详解65页 JAVA面试题汇总 ...volatile、ThreadLocal的使用场景和原理? ThreadLocal什么时候会出现OOM的情况?为什么? synchronized、volatile区别? synchronized锁粒度、模拟死锁场景?