亚洲精品无码国产片,亚洲va在线va天堂va四虎 ,亚洲熟妇无码av另类vr影视

Condition

@joe — Mon, 17 Oct 2011 09:28:00 GMT

Condition�Q�条�Ӟ�� ��?Object 监视器方法（wait�?code>notify �?notifyAll�Q�分解成截然不同的对象，以便通过��这些对象与��L�� Lock 实现�l�合使用�Q��ؓ每个对象提供多个�{�待 set �Q�wait-set�Q�。其中，Lock 替代�?synchronized �Ҏ��和语句的使用�Q?tt>Condition 替代�?Object 监视器方法的使用�?
下面解释�?font face="Courier New">Condition api里面的例�?生��者，消费�?�Q?br />

public class ConditionTest {

final Lock lock = new ReentrantLock();
     final Condition notFull = lock.newCondition(); //生��者的前提条�g�Q�没有达到次条�g��阻�?br />     final Condition notEmpty = lock.newCondition(); //消费者的前提条�g�Q�没有达到次条�g��阻�?br />
     final Object[] items = new Object[100];
     int putptr, takeptr, count;
  //生��
     public void put(Object x) throws InterruptedException {
       lock.lock();
       try {
         while (count == items.length)//如果满了�Q�就让需要条件�ؓ�Q�没满的的线�E?生��?�{?br />           notFull.await();
         items[putptr] = x;
         if (++putptr == items.length) putptr = 0;
         ++count;
         notEmpty.signal();//如果已经生��了，��p��需要条件�ؓ不�ؓ�I�的�U�程(消费�?执行
       } finally {
         lock.unlock();
       }
     }
//消费
     public Object take() throws InterruptedException {
       lock.lock();
       try {
         while (count == 0)//如果为空��p��需要条件�ؓ不�ؓ�I�的�U�程(消费�?�{?br />           notEmpty.await();
         Object x = items[takeptr];
         if (++takeptr == items.length) takeptr = 0;
         --count;
         notFull.signal();//如果消费了，��p��条�g��Z��满的�U�程(生��?执行
         return x;
       } finally {
         lock.unlock();
       }
     }
   }

@joe 2011-10-17 17:28 发表评论

ReadWriteLock

@joe — Mon, 17 Oct 2011 08:59:00 GMT

�U�程��d��同一个对象的数据是很普遍的，通常�Q�要避免��d��冲突�Q�必��M��证�Q何时候仅有一个线�E�在写入�Q�有�U�程正在��d��的时候，写入操作��必��ȝ��待。简单说�Q�就是要避免“�?�?#8221;冲突�?#8220;�?�?#8221;冲突。但是同时读是允许的�Q�因�?#8220;�?�?#8221;不冲�H�，而且很安全�?br /> 冲jdk1.5开始可以��用ReadWriteLock�c�L��防止��d��冲突.它有一个已有的实现ReentrantReadWriteLock�?br />ReentrantReadWriteLock使用内部�l�护的读写锁来防止读写冲�H�；

public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; }

�C�Z��代码如下�Q?br />

public class RreadWriteLockTest {

ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public int i = 0;
//��d��
public void read() throws InterruptedException{
  readWriteLock.readLock().lock();//获取读锁
  System.out.println("read thread:"+Thread.currentThread().getName());
  Thread.sleep(10000);
  System.out.println("read:"+i);
readWriteLock.readLock().unlock();
}
//写入
public void write() throws InterruptedException{

  readWriteLock.writeLock().lock();//获取写锁
  System.out.println("write thread:"+Thread.currentThread().getName());
  Thread.sleep(10000);
  i = 2;
  System.out.println("write:"+i);
readWriteLock.writeLock().unlock();
}
}
��试代码�Q?br />1 ��试两个同时�ȝ��Q�结果都能同时读取�?br />2 ��试一个读�Q�一个写的，需要其中一个释��N��之后才能�q�行另外一个操�?br />public static void main(String[] args) throws InterruptedException {
  final RreadWriteLockTest lockTest= new RreadWriteLockTest();
  new Thread(new Runnable() {

   @Override
   public void run() {
    try {
     lockTest.write();
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }).start();
  Thread.sleep(2000);
new Thread(new Runnable() {
    @Override
    public void run() {
     try {
      lockTest.read();
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
   }).start();
}
打印如下�Q?br />write thread:Thread-0执行完之�?10�U�之�?才执行read thread:Thread-1

注意�Q�执行完以后一定要执行unlock�Q�要不lock的计数没�?1�Q�这样对应read或者write的操作将无法�q�行�Q�一直等待�?/span>

@joe 2011-10-17 16:59 发表评论

synchronized 要注意的地方

@joe — Mon, 17 Oct 2011 02:56:00 GMT

在Java1.5之前�Q�synchronized应该是最常用的java支持�q�发手段。那synchronized是怎么做到的了�Q�从java1.0开始，java中的每个对象��׃��个内部锁。如果一个类的方法被synchronized关键字所修饰�Q�那么这个对象的锁将保护整个�Ҏ��?/p>

举例来说�Q?/p>

public synchronized void method(){

method body

}

�{��h�?/p>

public void method(){

this.intrinsicLock.lock();

try{

method body;

}finally(){

this.intrinsicLock.unlock();

}

从上面的代码�C�Z��可以看出�Q�synchronized的��用方式是比较��单的。这也导致了大量的初学者在��到java�~�程的时候落入陷阱里�Q�认为既然synhronized可以搞定一切，那么不管三七二十一�Q�只要有�q�发可能性的地方�Q�就加上synchronized的关键字�Q�这昄��是不对的。在java对象中，�q�个java对象只有�q�一个内部锁�Q�其中一个synchronized�Ҏ��获取��C��q�个锁，另外一个synchronized�Ҏ��的调用将被阻塞�?/p>

�?/p>

class sync{

public synchronized void methodA(){};

public synchronized void methodB(){};

... ...

}

methodA 和methodB在初始就是互斥的�Q�如果methodA和methodB�q�入互相�{�待�Q�就很容易出现死锁的情况。那如果��到�q�种情况�Q�应该怎么做了�Q�常用的方式是在�Ҏ��内部新徏一个无意义的对象，然后对这个无意义的对象加锅�?/p>

view plain copy to clipboard print ?

package zl.study.concurrency.synchronize;
public class Sync {
private int i;
public void plus(){
Object dummy = new Object();
synchronized(dummy){
i++;
}
}
public void minus(){
Object dummy = new Object();
synchronized(dummy){
i--;
}
}
}

另外需要注意的是将静态类声明为synchronized�Ҏ��也是合法的。�D例来��_��如果Sync有一个static synchronized�Ҏ��Q�那么这个方法被调用�?bank.class�q�个�c�d��象本�w�在jvm中将被锁�?/p>

@joe 2011-10-17 10:56 发表评论

AtomicInteger

@joe — Mon, 17 Oct 2011 02:53:00 GMT

AtomicInteger�Q�一个提供原子操作的Integer的类。在Java语言中，++i和i++操作�q�不是线�E�安全的�Q�在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一�U�线�E�安全的加减操作接口�?/p>

来看AtomicInteger提供的接口�?/p>

//获取当前的�?/p>

public final int get()

//取当前的��|��q�设�|�新的�?/p>

public final int getAndSet(int newValue)

//获取当前的��|��q�自�?/p>

public final int getAndIncrement()

//获取当前的��|��q�自�?/p>

public final int getAndDecrement()

//获取当前的��|��q�加上预期的�?/p>

public final int getAndAdd(int delta)

... ...

我们在上一节提到的CAS主要是这两个�Ҏ��

    public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    public final boolean weakCompareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

�q�两个方法是名称不同�Q�但是做的事是一��L��Q�可能在后箋的java版本里面会显�C�出区别来�?/p>

详细查看会发玎ͼ��q�两个接口都是调用一个unsafe的类来操作，�q�个是通过JNI实现的本地方法，�l�节��׃��考虑了�?/p>

下面是一个对比测试，我们写一个synchronized的方法和一个AtomicInteger的方法来�q�行��试�Q�直观的感受下性能上的差异

package zl.study.concurrency;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerCompareTest {
private int value;
public AtomicIntegerCompareTest(int value){
this.value = value;
}
public synchronized int increase(){
return value++;
}
public static void main(String args[]){
long start = System.currentTimeMillis();
AtomicIntegerCompareTest test = new AtomicIntegerCompareTest(0);
for( int i=0;i< 1000000;i++){
test.increase();
}
long end = System.currentTimeMillis();
System.out.println("time elapse:"+(end -start));
long start1 = System.currentTimeMillis();
AtomicInteger atomic = new AtomicInteger(0);
for( int i=0;i< 1000000;i++){
atomic.incrementAndGet();
}
long end1 = System.currentTimeMillis();
System.out.println("time elapse:"+(end1 -start1) );
}
}

�l�果

time elapse:31
time elapse:16
由此不难看出�Q�通过JNI本地的CAS性能�q�超synchronized关键�?/p>

Reference

http://stackoverflow.com/questions/2443239/java-atomicinteger-what-are-the-differences-between-compareandset-and-weakcompar

@joe 2011-10-17 10:53 发表评论

CountDownLatch ��介和例子

@joe — Mon, 04 Jul 2011 09:14:00 GMT

在一些应用场合中�Q�某�D늨�序需要等待某个条件达到要求后才能执行�Q�或者等待一定长的时间后此行�Q�从jdk1.5开始就可以使用CountDownLatch实现�Q?nbsp;
CountDownLatch�c�L��一个同步倒数计数�?构造时传入int参数,该参数就是计数器的初始��|��每调用一�ơcountDown()�Ҏ��Q�计数器�?,计数器大�? �Ӟ��await()�Ҏ��会阻塞后面程序执行，直到计数器�ؓ0�Q�await(long timeout, TimeUnit unit)�Q�是�{�待一定时��_��然后执行�Q�不��计数器是否�?了�?br />下面举一个等车的例子�Q?br />10个同学上车，车等待同学上车，如果有等待时间限�Ӟ��到时间就开赎ͼ�不管学生上没上完。如果没有等待时��_��学生上完了再开�Q?

public class CountDownLatchTest {
    public static int numberOfPeople = 10;//�{��R的学生数
    public static boolean isGone = false;//车开的标�?/span>
    public static int carWaitTime = 3;//车等的时�?/span>

    public static void main(String[] args) throws InterruptedException {

        CountDownLatch waitStudentsGetOn = new CountDownLatch(numberOfPeople);

        new Thread(new GetOn(waitStudentsGetOn)).start();

        waitStudentGetOn(waitStudentsGetOn);//�{�所有的学生上�R

        driveHome();//开车走

    }

    private static void waitStudentGetOn(CountDownLatch waitStudentsGetOn) throws InterruptedException {
        System.out.println("赶紧�?抓紧旉��上�R..");
        waitStudentsGetOn.await(carWaitTime, TimeUnit.SECONDS);//�{?�U�，�q�没上�R�Q�就开走。�?/span>

    }

    private static void driveHome() throws InterruptedException {
        System.out.println("开车，鞋儿�?nbsp;帽儿�?nbsp;�w�上的袈裟破你笑�?nbsp;他笑�?nbsp;一把扇儿破");
        isGone = true;

    }

}
class GetOn implements Runnable{

    private CountDownLatch waitStudentsGetOn;
    GetOn(CountDownLatch waitStudentsGetOn){
        this.waitStudentsGetOn = waitStudentsGetOn;
    }
    public void run() {
        for (int i = 0; i < CountDownLatchTest.numberOfPeople; i++) {
            try {
                if(CountDownLatchTest.isGone){
                    System.out.println("妈的�Q�还差："+waitStudentsGetOn.getCount()+" 个没娃上车呢.怎么车走�?/span>");
                    break;
                }
                boolean goonSuccess = new Student(i+1).getOn();//��序上�R
                if(goonSuccess)waitStudentsGetOn.countDown();
            } catch (InterruptedException e) {}
                if(waitStudentsGetOn.getCount()!=0l){
                    System.out.println("�q�差�Q?/span>"+(waitStudentsGetOn.getCount())+" 个没上�R");
                }else{
                    System.out.println("都上车了");
                }
        }


    }
    class Student{
        private int myNum;//学生�~�号
         public Student(int num){
                this.myNum = num;
          }
         //上�R
         public boolean getOn() throws InterruptedException{
             Thread.currentThread().sleep(new Random().nextInt(2)*1000);//上�R使用的时��_��随机
             if(CountDownLatchTest.isGone){
                 return false;//不能上了�Q�上车失�?/span>
             }
             System.out.print("�~�号�?"+myNum+"的同学上车了..");
             return true;
         }
    }
}