<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    ゞ沉默是金ゞ

    魚離不開水,但是沒有說不離開哪滴水.
    posts - 98,comments - 104,trackbacks - 0
    In this article we will look into Atomic Variables which can help us to write lock free and wait free algorithms which were not possible prior to Java 5.0.

    Two main points about Atomic Variables are 

       1. Help to write lock free and wait free algorithm

    Under high contention ( lots of thread are fighting for lock ), JVM spends more time with scheduling of threads, managing contention, queues of waiting threads and less time in doing the real work.
    This dramatically reduces the throughput of the process.
    Problem with locking:
      1) Thread in block state cannot do anything else.
        2) If the blocked thread is high priority, then its a big disaster.
        3) Can cause Dead lock
        4) Managing a Block thread is a heavy weight process, so throughput decreases.

    Soon we will see how can we write lock free algorithms using atomic variables


    2. Implement very light weight process like CAS –


    CAS (compares and swap):
           
    Let’s take an example to understand the concept of CAS. Suppose we have once variable “i” and we are doing some calculation over “I” and storing the result back into “i”. In a nutshell-
            i = someComplicateComputation( i )
    for “i” = 1,
            someComplicatedComputation(i) è 1234

    In CAS Process following happens-
            A memory location V will be defined.
            A local variable A will be defined.
            A local variable B will be defined.

    V will hold the initial value of “i”. So
            V = i =1
    A = V = 1
    B = result of that computation = 1234
    compare ( V , A )
    if
    both values are same --> replace V with B's value.
    else
            this means in the mean while someone has changed the value of V, so repeat the whole process again. Lets someone changes the value of “i”, hence V to 2.
           
                 V = 2;
                 A = V = 2
                 B = result = 3246;
                  compare ( V , A )
                            and so on...!!
           
    This is very light weight process. This CAS technique is implemented by atomic package classes.



    Example – Lets write a simple program which first increase the number by 1, then decrease the number by 1, and then increase again by 1. So overall effect is increase the number by 1. Lets run 4 threads concurrently access the method and compare the performance of AtomicInteger Vs Integer.

    package com.jovialjava.blog.threads;

    import java.util.concurrent.atomic.*;

    public class AtomicVariableExample implements Runnable {
        AtomicInteger atomic_int_1 
    = new AtomicInteger();
        AtomicInteger atomic_int_2 
    = new AtomicInteger();
        
    int int_1;
        
    int int_2;
        
    private static int count = 0;

        
    public static void main(String[] args) {
            AtomicVariableExample pr 
    = new AtomicVariableExample();
            
    new Thread(pr).start();// 1 0 1
            new Thread(pr).start();// 2 1 2
            new Thread(pr).start(); // 3 2 3
            new Thread(pr).start(); // 4 3 4
            while (true) {
                
    if (count == 4) {
                    System.out.println(pr.atomic_int_1.get());
                    System.out.println(pr.int_1);
                    
    break;
                }
            }

        }

        
    public void run() {
            System.out.println(
    "Inside run method");
            doCalc();

        }

        
    private void doCalc() {
            
    try {
                atomic_int_2 
    = atomic_int_1;
                int_2 
    = int_1;
                atomic_int_2.incrementAndGet();
                int_2 
    = int_2 + 1;
                Thread.sleep(
    1000);
                atomic_int_2.decrementAndGet();
                int_2 
    = int_2 - 1;
                Thread.sleep(
    1000);
                atomic_int_2.incrementAndGet();
                int_2 
    = int_2 + 1;
                Thread.sleep(
    1000);
                atomic_int_1 
    = atomic_int_2;
                int_1 
    = int_2;
                
    synchronized (this) {
                    count
    ++;
                }
            } 
    catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    posted on 2012-08-06 10:50 ゞ沉默是金ゞ 閱讀(967) 評論(0)  編輯  收藏 所屬分類: Java SE
    主站蜘蛛池模板: 亚洲αv在线精品糸列| 一本到卡二卡三卡免费高| 亚洲日韩精品一区二区三区无码| 日韩中文字幕精品免费一区| 在线免费视频你懂的| 亚洲精品理论电影在线观看| 亚洲国产成人久久精品app| 久久被窝电影亚洲爽爽爽| 亚洲第一黄色网址| 97无码免费人妻超级碰碰夜夜| 一区二区三区四区免费视频| 成全视成人免费观看在线看| 四虎影视在线看免费观看| 亚洲av无码专区在线观看亚| 亚洲人成网站色7799| 亚洲免费视频观看| 久久亚洲AV无码精品色午夜| 亚洲春色在线视频| 亚洲一区二区三区偷拍女厕| 亚洲欧洲国产成人综合在线观看| 亚洲&#228;v永久无码精品天堂久久| 成人免费无码大片a毛片软件| 免费国产作爱视频网站| 四虎永久在线精品免费观看视频| 日韩精品极品视频在线观看免费| 最近免费mv在线观看动漫| 美女被免费网站91色| 国产免费A∨在线播放| 新最免费影视大全在线播放| 色婷婷精品免费视频| 污污视频网站免费观看| 免费在线人人电影网| 青青草97国产精品免费观看 | 久久www免费人成精品香蕉| 色吊丝性永久免费看码| 午夜不卡AV免费| 三年片免费高清版| 国产免费一区二区三区在线观看| 99久久国产精品免费一区二区| 波多野结衣免费一区视频| 热re99久久6国产精品免费|