亚洲精品成人久久,亚洲精品视频免费在线观看,亚洲成色999久久网站

java中的volatile和synchronized

abing — Fri, 19 Oct 2012 05:36:00 GMT

�q�个可能是最好的�Ҏ(gu��)��volatile 和synchronized 作用的文章了。volatile 是一个变量修饰符�Q�而synchronized 是一个方法或块的修饰�W�。所以我们��用这两种关键字来指定三种��单的存取变量的方式�?/span>

int i1; int geti1() {return i1;}

volatile int i2; int geti2() {return i2;}

int i3; synchronized int geti3() {return i3;}

geti1() �?strong>当前�U�程中立卌��取在i1 变量中的倹{��线�E�可以获得变量的本地拯��Q�而所获得的变量的值�ƈ不一定与其他�U�程所获得的值相同。特别是�Q�如果其他的�U�程修改了i1 的��|��那么当前�U�程获得的i1 的值可能与修改后的值有所差别。实际上�Q�Java 有一�U�主内存的机�Ӟ��使用一个主内存来保存变量当前的正确的倹{��线�E�将变量的值拷贝到自己独立的内存中�Q�而这些线�E�的内存拯��可能与主内存中的��g��同。所以实际当中可能发生这��L(f��ng)��情况�Q�在��d��存中i1 的��gؓ(f��)1 �Q�线�E? 和线�E? 都更改了i1 �Q�但是却没把更新的��g��回给��d��存或其他�U�程中，那么可能在线�E? 中i1 的��gؓ(f��)2�Q�线�E? 中i1 的值却�?nbsp;3 �?/span>

另一斚w��Q�geti2() 可以有效的从��d��存中获取i2 的倹{��一个volatile �c�d��的变量不允许�U�程从主内存中将变量的值拷贝到自己的存储空间。因此，一个声明�ؓ(f��)volatile �c�d��的变量将在所有的�U�程中同步的获得数据�Q�不��Z��在�Q何线�E�中更改了变量，其他的线�E�将立即得到同样的结果。由于线�E�存取或更改自己的数据拷贝有更高的效率，所以volatile �c�d��变量在性能上有所消耗�?/span>

那么如果volatile 变量已经可以使数据在�U�程间同步，那么synchronizes 用来�q�什么呢�Q�两者有两方面的不同。首先，synchronized 获取和释攄��监听器控制的锁，如果两个�U�程都��用一个监听器( 即相同对象锁) �Q�那么监听器可以强制在一个时��d��有一个线�E�能处理代码块，�q�是最一般的同步。另外，synchronized �q�能使内存同步。在实际当中�Q�synchronized 使得所有的�U�程内存与主内存相同步。所以geti3() 的执行过�E�如下：(x��)

1. �U�程从监听器获取对象的锁�? �q�里假设监听器非锁，否则�U�程只有�{�到监听器解锁才能获取对象锁)

2. �U�程内存更新所�?/strong> 的变量，也就是说他将��d��d��存中的变量��自己的变量保证有效�?JVM �?x��)��用一�?#8220;�?#8221;标志来最优化�q�程�Q��得仅仅具�?#8220;�?#8221;标志变量被更新。详�l�的情况查询JAVA规范�?7.9)

3. 代码块被执行( 在这个例子中�Q�设�|�返回��gؓ(f��)刚刚从主内存重置的i3 当前的倹{�?

4. ��M��变量的变更将被写回到��d��存中。但是这个例子中geti3() 没有什么变化�?/span>

5. �U�程释放对象的锁�l�监听器�?/span>

所以volatile 只能在线�E�内存和��d��存之间同步一个变量的��|��而synchronized 则同步在�U�程内存和主内存之间的所有变量的��|��q�且通过锁住和释攄��听器来实现。显�Ӟ��synchronized 在性能上将比volatile 更加有所消耗�?/span>

=============关于两者的区别===================

1.volatile本质是在告诉jvm当前变量在寄存器�Q�工作内存）中的值是不确定的�Q�需要从��d��中读取；synchronized则是锁定当前变量�Q�只有当前线�E�可以访问该变量�Q�其他线�E�被��d��住�?nbsp;
2.volatile仅能使用在变量��别；synchronized则可以��用在变量、方法、和�cȝ�别的
3.volatile仅能实现变量的修改可见性，不能保证原子�?/span> �Q�而synchronized则可以保证变量的修改可见性和原子�?nbsp;
4.volatile不会(x��)造成�U�程的阻塞；synchronized可能�?x��)造成�U�程的阻塞�?nbsp;
5.volatile标记的变量不�?x��)被�~�译器优化；synchronized标记的变量可以被�~�译器优�?/p>

�U�字体部分的原因如下�Q?br />�U�程A修改了变量还没结束时,另外的线�E�B可以看到已修改的�?而且可以修改�q�个变量,而不用等待A释放�?因�ؓ(f��)Volatile 变量没上�?/p>

abing 2012-10-19 13:36 发表评论

java 死锁

abing — Wed, 17 Oct 2012 07:48:00 GMT

死锁死锁是这样一�U�情形：(x��)多个�U�程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线�E�被无限期地��d��Q�因此程序不可能正常�l�止�? ��D��死锁的根源在于不适当地运�?#8220;synchronized”关键词来��理�U�程对特定对象的讉K��?#8220;synchronized”关键词的作用是，��保在某个时��d��有一个线�E�被允许执行特定的代码块�Q�因此，被允许执行的�U�程首先必须拥有对变量或对象的排他性的讉K��权。当�U�程讉K��对象�Ӟ��U�程�?x��)给对象加锁�Q�而这个锁��D��其它也想讉K��同一对象的线�E�被��d��Q�直至第一个线�E�释攑֮�加在对象上的锁�? �׃��q�个原因�Q�在使用“synchronized”关键词时�Q�很�Ҏ(gu��)��出现两个�U�程互相�{�待�Ҏ(gu��)��做出某个动作的情形。代码一是一个导致死锁的��单例子�? //代码一 class Deadlocker { int field_1; private Object lock_1 = new int[1]; int field_2; private Object lock_2 = new int[1]; public void method1(int value) { “synchronized” (lock_1) { “synchronized” (lock_2) { field_1 = 0; field_2 = 0; } } } public void method2(int value) { “synchronized” (lock_2) { “synchronized” (lock_1) { field_1 = 0; field_2 = 0; } } } } 参考代码一�Q�考虑下面的过�E�：(x��) ◆ 一个线�E�（ThreadA�Q�调用method1()�? ◆ ThreadA在lock_1上同步，但允许被抢先执行�? ◆ 另一个线�E�（ThreadB�Q�开始执行�? ◆ ThreadB调用method2()�? ◆ ThreadB获得lock_2�Q��l�执行，企图获得lock_1。但ThreadB不能获得lock_1�Q�因为ThreadA占有lock_1�? ◆ 现在�Q�ThreadB��d��Q�因为它在等待ThreadA释放lock_1�? ◆ 现在轮到ThreadA�l�箋执行。ThreadA试图获得lock_2�Q�但不能成功�Q�因为lock_2已经被ThreadB占有了�? ◆ ThreadA和ThreadB都被��d��Q�程序死锁�? 当然�Q�大多数的死锁不�?x��)这么显而易见，需要仔�l�分析代码才能看出，对于规模较大的多�U�程�E�序来说��其如此。好的线�E�分析工��P��例如JProbe Threadalyzer能够分析死锁�q�指��Z�生问题的代码位置�? 隐性死�? 隐性死锁由于不规范的编�E�方式引��P��但不一定每�ơ测试运行时都会(x��)出现�E�序死锁的情形。由于这个原因，一些隐性死锁可能要到应用正式发布之后才�?x��)被发现�Q�因此它的危��x��比普通死锁更大。下面介�l�两�U�导致隐性死锁的情况�Q�加锁次序和占有�q�等待�? 加锁�ơ序当多个�ƈ发的�U�程分别试图同时占有两个锁时�Q�会(x��)出现加锁�ơ序冲突的情形。如果一个线�E�占有了另一个线�E�必需的锁�Q�就有可能出现死锁。考虑下面的情形，ThreadA和ThreadB两个�U�程分别需要同时拥有lock_1、lock_2两个锁，加锁�q�程可能如下�Q? ◆ ThreadA获得lock_1�Q? ◆ ThreadA被抢占，VM调度�E�序转到ThreadB�Q? ◆ ThreadB获得lock_2�Q? ◆ ThreadB被抢占，VM调度�E�序转到ThreadA�Q? ◆ ThreadA试图获得lock_2�Q�但lock_2被ThreadB占有�Q�所以ThreadA��d��Q? ◆ 调度�E�序转到ThreadB�Q? ◆ ThreadB试图获得lock_1�Q�但lock_1被ThreadA占有�Q�所以ThreadB��d��Q? ◆ ThreadA和ThreadB死锁�? 必须指出的是�Q�在代码丝毫不做变动的情况下�Q�有些时候上�q�死锁过�E�不�?x��)出玎ͼ�VM调度�E�序可能让其中一个线�E�同时获得lock_1和lock_2两个锁，即线�E�获取两个锁的过�E�没有被中断。在�q�种情�Ş下，常规的死锁检��很隄��定错误所在�? 占有�q�等�? 如果一个线�E�获得了一个锁之后�q�要�{�待来自另一个线�E�的通知�Q�可能出现另一�U�隐性死锁，考虑代码二�? //代码�?public class queue { static java.lang.Object queueLock_; Producer producer_; Consumer consumer_; public class Producer { void produce() { while (!done) { “synchronized” (queueLock_) { produceItemAndAddItToQueue(); “synchronized” (consumer_) { consumer_.notify(); } } } } public class Consumer { consume() { while (!done) { “synchronized” (queueLock_) { “synchronized” (consumer_) { consumer_.wait(); } removeItemFromQueueAndProcessIt(); } } } } } } 在代码二中，Producer向队列加入一��Ҏ(gu��)��的内容后通知Consumer�Q�以便它处理新的内容。问题在于，Consumer可能保持加在队列上的锁，��L��Producer讉K��队列�Q�甚臛_��Consumer�{�待Producer的通知时也�?x��)��l�保持锁。这��P��׃��Producer不能向队列添加新的内容，而Consumer却在�{�待Producer加入新内容的通知�Q�结果就��D��了死锁�? 在等待时占有的锁是一�U�隐性的死锁�Q�这是因��Z��情可能按照比较理想的情况发展—Producer�U�程不需要被Consumer占据的锁。尽��如此，除非有绝对可靠的理由肯定Producer�U�程永远不需要该锁，否则�q�种�~�程方式仍是不安全的。有�?#8220;占有�q�等�?#8221;�q�可能引发一�q�串的线�E�等待，例如�Q�线�E�A占有�U�程B需要的锁�ƈ�{�待�Q�而线�E�B又占有线�E�C需要的锁�ƈ�{�待�{��? 要改正代码二的错误，只需修改Consumer�c�，把wait()�U�d��“synchronized”()卛_��?/pre>
参考资料：(x��)http://software.ccidnet.com/art/322/20030410/43222_1.html

abing 2012-10-17 15:48 发表评论

abing — Fri, 12 Oct 2012 15:43:00 GMT

�W�一�U�：(x��)�Q�Thread�Q?br />
package com.abin.lee.servlet.mythread.thread;

public class Mythread extends Thread{
private String name;
public Mythread(String name) {
  this.name=name;
}
public void run() {
  synchronized(this.name){
   System.out.println("开始时��_(d��)��(x��)"+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
   System.out.println("name="+name);
   System.out.println("�l�束旉��Q?+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());

  }
}

}

��试代码�Q?br />
package com.abin.lee.servlet.mythread.thread;

public class MythreadTest {
public static void main(String[] args) {
  Mythread mythread1=new Mythread("ManyThread");
  Mythread mythread2=new Mythread("ManyThread");
  mythread1.start();
  mythread2.start();
}

}

�W�二�U�：(x��)�Q�Runnable�Q?br />
package com.abin.lee.servlet.mythread.runnable;

public class MyRunnable implements Runnable{
private String name;
public MyRunnable(String name) {
  this.name=name;
}
public synchronized void run(){
   System.out.println("开始时��_(d��)��(x��)"+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
   System.out.println("name="+name);
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("�l�束旉��Q?+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
}
}

��试代码�Q?br />
package com.abin.lee.servlet.mythread.runnable;

public class MyRunnableTest {
public static void main(String[] args) {
  MyRunnable myRunnable=new MyRunnable("ManyThread");
  Thread thread1=new Thread(myRunnable);
  Thread thread2=new Thread(myRunnable);
  thread1.start();
  thread2.start();
}
}

�W�三�U�：(x��)�Q�Callable�Q�这�U�说明一下，�q�个实现多线�E�的方式是在JDK1.5引进的，在java.util.concurrent.Callable �q�个�q�发包下面，�q�且提供同步�q�回�l�果的多�U�程�?br />
package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyCallable implements Callable{
private String name;
public MyCallable(String name) {
  this.name=name;
}
public String call() throws Exception {
  Lock lock=new ReentrantLock();
  lock.lock();
  String result="";
  try {
   System.out.println("开始时��_(d��)��(x��)"+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());
   System.out.println("name="+name);
   if(name.equals("ManyThread")){
    result="success";
   }else{
    result="failure";
   }
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("�l�束旉��Q?+System.currentTimeMillis()+",�U�程名字�Q?+Thread.currentThread().getName());

  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   lock.unlock();
  }

   return result;

}

}

��试代码�Q?br />
package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Test;

public class MyCallableTest {
@Test
public void testMyCallable() throws InterruptedException, ExecutionException{
  ExecutorService executor=Executors.newFixedThreadPool(3);
  MyCallable myCallable=new MyCallable("ManyThread");
  Future future1=executor.submit(myCallable);
  System.out.println("future1="+future1.get());
  Future future2=executor.submit(myCallable);
  System.out.println("future2="+future2.get());
  Future future3=executor.submit(myCallable);
  System.out.println("future3="+future3.get());

}

}

��试�l�果�Q?br />
开始时��_(d��)��(x��)1350056647659,�U�程名字�Q�pool-1-thread-1
name=ManyThread
�l�束旉��Q?350056650661,�U�程名字�Q�pool-1-thread-1
future1=success
开始时��_(d��)��(x��)1350056650661,�U�程名字�Q�pool-1-thread-2
name=ManyThread
�l�束旉��Q?350056653661,�U�程名字�Q�pool-1-thread-2
future2=success
开始时��_(d��)��(x��)1350056653662,�U�程名字�Q�pool-1-thread-3
name=ManyThread
�l�束旉��Q?350056656663,�U�程名字�Q�pool-1-thread-3
future3=success

abing 2012-10-12 23:43 发表评论