Java同步与异步Word格式.docx
《Java同步与异步Word格式.docx》由会员分享，可在线阅读，更多相关《Java同步与异步Word格式.docx（14页珍藏版）》请在冰点文库上搜索。
监控器是一个控制机制，可以认为是一个很小的、只能容纳一个线程的盒子，一旦一个线程进入监控器，其它的线程必须等待，直到那个线程退出监控为止。
通过这种方式，一个监控器可以保证共享资源在同一时刻只可被一个线程使用。
这种方式称之为同步。
（一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例的非同步方法仍然能够被调用）。
错误的理解：
同步嘛，就是几个线程可以同时进行访问。
同步和多线程关系：
没多线程环境就不需要同步;
有多线程环境也不一定需要同步。
锁提供了两种主要特性：
互斥（mutualexclusion）和可见性（visibility）。
互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。
可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的——如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题
小结：
为了防止多个线程并发对同一数据的修改，所以需要同步，否则会造成数据不一致（就是所谓的：
线程安全。
如java集合框架中Hashtable和Vector是线程安全的。
我们的大部分程序都不是线程安全的，因为没有进行同步，而且我们没有必要，因为大部分情况根本没有多线程环境）。
2、什么叫原子的（原子操作）？
Java原子操作是指：
不会被打断地的操作。
（就是做到互斥和可见性？
！
）
那难道原子操作就可以真的达到线程安全同步效果了吗？
实际上有一些原子操作不一定是线程安全的。
那么，原子操作在什么情况下不是线程安全的呢？
也许是这个原因导致的：
java线程允许线程在自己的内存区保存变量的副本。
允许线程使用本地的私有拷贝进行工作而非每次都使用主存的值是为了提高性能（本人愚见：
虽然原子操作是线程安全的，可各线程在得到变量（读操作）后，就是各自玩弄自己的副本了，更新操作（写操作）因未写入主存中，导致其它线程不可见）。
那该如何解决呢？
因此需要通过java同步机制。
在java中，32位或者更少位数的赋值是原子的。
在一个32位的硬件平台上，除了double和long型的其它原始类型通常都是使用32位进行表示，而double和long通常使用64位表示。
另外，对象引用使用本机指针实现，通常也是32位的。
对这些32位的类型的操作是原子的。
这些原始类型通常使用32位或者64位表示，这又引入了另一个小小的神话：
原始类型的大小是由语言保证的。
这是不对的。
java语言保证的是原始类型的表数范围而非JVM中的存储大小。
因此，int型总是有相同的表数范围。
在一个JVM上可能使用32位实现，而在另一个JVM上可能是64位的。
在此再次强调：
在所有平台上被保证的是表数范围，32位以及更小的值的操作是原子的。
3、不要搞混了：
同步、异步
举个例子：
普通B/S模式（同步）AJAX技术（异步）
同步：
提交请求->
等待服务器处理->
处理完返回这个期间客户端浏览器不能干任何事
异步：
请求通过事件触发->
服务器处理（这是浏览器仍然可以作其他事情）->
处理完毕
可见，彼“同步”非此“同步”——我们说的java中的那个共享数据同步（synchronized）
一个同步的对象是指行为（动作），一个是同步的对象是指物质（共享数据）。
4、Java同步机制有4种实现方式：
（部分引用网上资源）
①
ThreadLocal②synchronized（）③wait（）与notify（）④volatile
目的：
都是为了解决多线程中的对同一变量的访问冲突
ThreadLocal
ThreadLocal保证不同线程拥有不同实例，相同线程一定拥有相同的实例，即为每一个使用该变量的线程提供一个该变量值的副本，每一个线程都可以独立改变自己的副本，而不是与其它线程的副本冲突。
优势：
提供了线程安全的共享对象
与其它同步机制的区别：
同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信；
而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源，这样当然不需要多个线程进行同步了。
volatile
volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。
优势：
这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
缘由：
Java语言规范中指出，为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。
这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
而volatile关键字就是提示VM：
对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用技巧：
在两个或者更多的线程访问的成员变量上使用volatile。
当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。
线程为了提高效率，将某成员变量（如A）拷贝了一份（如B），线程中对A的访问其实访问的是B。
只在某些动作时才进行A和B的同步，因此存在A和B不一致的情况。
volatile就是用来避免这种情况的。
volatile告诉jvm，它所修饰的变量不保留拷贝，直接访问主内存中的（读操作多时使用较好；
线程间需要通信，本条做不到）
Volatile变量具有synchronized的可见性特性，但是不具备原子特性。
这就是说线程能够自动发现volatile变量的最新值。
Volatile变量可用于提供线程安全，但是只能应用于非常有限的一组用例：
多个变量之间或者某个变量的当前值与修改后值之间没有约束。
您只能在有限的一些情形下使用volatile变量替代锁。
要使volatile变量提供理想的线程安全，必须同时满足下面两个条件：
对变量的写操作不依赖于当前值；
该变量没有包含在具有其他变量的不变式中。
sleep（）vswait（）
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。
调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
（如果变量被声明为volatile，在每次访问时都会和主存一致；
如果变量在同步方法或者同步块中被访问，当在方法或者块的入口处获得锁以及方法或者块退出时释放锁时变量被同步。
四、例子：
Demo1:
packagetest.thread;
/**
*
*@authorydj
*/
classSynTest{
//非同步
staticvoidmethod（Threadthread）{
System.out.println（"
begin"
+thread.getName（））;
try{
Thread.sleep（2000）;
}catch（Exceptionex）{
ex.printStackTrace（）;
}
end"
//同步方式一：
同步方法
synchronizedstaticvoidmethod1（Threadthread）{//这个方法是同步的方法，每次只有一个线程可以进来
//同步方式二：
同步代码块
staticvoidmethod2（Threadthread）{
synchronized（SynTest.class）{
//同步方式三：
使用同步对象锁
privatestaticObject_lock1=newObject（）;
privatestaticbyte_lock2[]={};
//据说，此锁更可提高性能。
源于：
锁的对象越小越好
staticvoidmethod3（Threadthread）{
synchronized（_lock1）{
publicstaticvoidmain（String[]args）{
//启动3个线程，这里用了匿名类
for（inti=0;
i<
3;
i++）{
newThread（）{
publicvoidrun（）{
method（this）;
//method1（this）;
//method2（this）;
//method3（this）;
}.start（）;
}
执行method（）方法结果：
beginThread-0
beginThread-2
beginThread-1
endThread-1
endThread-0
endThread-2
说明了:
在没有同步限制的条件下,多个线程可以同时进入一个对象的方法中操作。
这样对共享可变数据是不安全的，即常说的：
非线程安全（nonthread-safe）。
执行method1（）/method2（）/method3（）方法结果（可能线程进入的顺序不同）：
在同步限制的条件下,同时只可有一个线程进入一个对象的方法中操作，其它线程必须等待先它的线程退出后才可进入。
这样可保证共享可变数据是安全的，即常说的：
线程安全（thread-safe）。
Demo2:
importcom.util.LogUtil;
publicclassSynTest2{
Callmetarget=newCallme（）;
Callerob1=newCaller（target,"
Hello"
）;
Callerob2=newCaller（target,"
Synchronized"
Callerob3=newCaller（target,"
World"
classCallme{
/**
*有和没有synchronized的时候，结果是不一样的
*/
synchronizedvoidtest（）{
LogUtil.log（"
测试是否是：
一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例的非同步方法仍然能够被调用"
voidnonsynCall（Stringmsg）{
["
+msg）;
]"
synchronizedvoidsynCall（Stringmsg）{
LogUtil.logPrint（"
classCallerimplementsRunnable{
Stringmsg;
Callmetarget;
Threadt;
Caller（Callmetarget,Stringmsg）{
this.target=target;
this.msg=msg;
t=newThread（this）;
t.start（）;
publicvoidrun（）{
//TODOAuto-generatedmethodstub
//target.nonsynCall（msg）;
target.synCall（msg）;
target.test（）;
升级会员 