??xml version="1.0" encoding="utf-8" standalone="yes"?>国产成人人综合亚洲欧美丁香花,亚洲日韩国产一区二区三区在线,亚洲AV无码国产在丝袜线观看http://www.tkk7.com/xylz/category/45607.htmlx后端架构、中间g、分布式和ƈ发编E?/description>zh-cnFri, 29 Nov 2013 12:38:07 GMTFri, 29 Nov 2013 12:38:07 GMT60随机选择集合的子元素集合http://www.tkk7.com/xylz/archive/2013/08/17/402978.htmlimxylzimxylzSat, 17 Aug 2013 09:44:00 GMThttp://www.tkk7.com/xylz/archive/2013/08/17/402978.htmlhttp://www.tkk7.com/xylz/comments/402978.htmlhttp://www.tkk7.com/xylz/archive/2013/08/17/402978.html#Feedback1http://www.tkk7.com/xylz/comments/commentRss/402978.htmlhttp://www.tkk7.com/xylz/services/trackbacks/402978.html我需要一个从集合N中随机选择M个子元素的算法?当然最好的办法是将集合打ؕ序Q然后从中选择前M个元素即可?Java中现成的API可以使用Q?/div>
java.util.Collections.shuffle(List<?>)
此算法非常简单,循环Nơ,每次长度减少1Q随取其中一个元素,然后交换其对U元素?/div>
public static void shuffle(List<?> list, Random rnd) {
    int size = list.size();
    if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
        for (int i=size; i>1; i--)
            swap(list, i-1, rnd.nextInt(i));
    } else {
        Object arr[] = list.toArray();

        // Shuffle array
        for (int i=size; i>1; i--)
            swap(arr, i-1, rnd.nextInt(i));

        // Dump array back into list
        ListIterator it = list.listIterator();
        for (int i=0; i<arr.length; i++) {
            it.next();
            it.set(arr[i]);
        }
    }
}

有点意思的swap函数

public static void swap(List<?> list, int i, int j) {
    final List l = list;
    l.set(i, l.set(j, l.get(i)));
}

其实我们的需求很单,在基本不变的集合中,多次重复随机获取其子集,至于子集是否有序或者随Z重要的, 重要的是原集合中的每个元素都有相似的概率出现在子集合中?/div>

考虑到性能以及q发讉KQ多U程Q的需要,我想C一个简单的法Q?/div>
l定N个元素集合,从中选择M(0<M<=N)个元素的办法是,
  1. 随机选择索引K(0<=K<N), i=0, I子?/li>
  2. 取有效元素N(k-i),N(k+i) 加入未满子集M
  3. i+=1, 重复(2) 直到子集M已满
  4. l止
q样取出来的元素虽然和原始集序有一定的关系Q但是每个元素在子集里出现的概率相当Q满结果要求?最后生成的法如下Q?/div>
public static <T> List<T> randomList(List<T> views, int max) {

    final int size = views.size();
    int index = RandomUtils.nextInt(size);
    //
    List<T> ret = new ArrayList<T>(max);
    int low = index - 1, high = index;
    while (max > 0 && (low >= 0 || high < size)) {
        if (low >= 0 && max-- > 0) {
            ret.add(views.get(low));
        }
        if (high < size && max-- > 0) {
            ret.add(views.get(high));
        }
        low--;
        high++;
    }
    return ret;
}

此算法满_下特点:
  1. _?/li>
  2. U程安全Q原始集合不变)
  3. 子元素出现概率相当(未经数学证明

另外Qstackoverflow上也有一些参考链接:



imxylz 2013-08-17 17:44 发表评论
]]>捕获JavaU程池执行Q务抛出的异常http://www.tkk7.com/xylz/archive/2013/08/05/402405.htmlimxylzimxylzMon, 05 Aug 2013 08:45:00 GMThttp://www.tkk7.com/xylz/archive/2013/08/05/402405.htmlhttp://www.tkk7.com/xylz/comments/402405.htmlhttp://www.tkk7.com/xylz/archive/2013/08/05/402405.html#Feedback3http://www.tkk7.com/xylz/comments/commentRss/402405.htmlhttp://www.tkk7.com/xylz/services/trackbacks/402405.htmlJava中线E执行的d接口java.lang.Runnable 要求不抛出Checked异常Q?/p>
public interface Runnable {

    
public abstract void run();
}

那么如果 run() Ҏ中抛ZRuntimeExceptionQ将会怎么处理了?

通常java.lang.Thread对象q行讄一个默认的异常处理ҎQ?/p>

java.lang.Thread.setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler)

而这个默认的静态全局的异常捕h法时输出堆栈?/p>

当然Q我们可以覆盖此默认实现Q只需要一个自定义的java.lang.Thread.UncaughtExceptionHandler接口实现卛_?/p>

public interface UncaughtExceptionHandler {

    
void uncaughtException(Thread t, Throwable e);
}

而在U程池中却比较特D。默认情况下Q线E池 java.util.concurrent.ThreadPoolExecutor 会Catch住所有异常, 当Q务执行完?java.util.concurrent.ExecutorService.submit(Callable))获取其结??java.util.concurrent.Future.get())会抛出此RuntimeException?/t>

/**
 * Waits if necessary for the computation to complete, and then
 * retrieves its result.
 *
 * 
@return the computed result
 * 
@throws CancellationException if the computation was cancelled
 * 
@throws ExecutionException if the computation threw an exception
 * 
@throws InterruptedException if the current thread was interrupted while waiting
 
*/
V get() 
throws InterruptedException, ExecutionException;

其中 ExecutionException 异常xjava.lang.Runnable 或?java.util.concurrent.Callable 抛出的异常?/p>

也就是说Q线E池在执行Q务时捕获了所有异常,q将此异常加入结果中。这样一来线E池中的所有线E都无法捕获到抛出的异常?从而无法通过讄U程的默认捕h法拦截的错误异常?/p>

也不同通过自定义线E?/a>来完成异常的拦截?/p>

好在java.util.concurrent.ThreadPoolExecutor 预留了一个方法,q行在Q务执行完毕进行扩展(当然也预留一个protectedҎbeforeExecute(Thread t, Runnable r)Q:

protected void afterExecute(Runnable r, Throwable t) { } 

此方法的默认实现为空Q这h们就可以通过l承或者覆盖ThreadPoolExecutor 来达到自定义的错误处理?/p>

解决办法如下Q?/p>

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(111001, TimeUnit.MINUTES, //
        new ArrayBlockingQueue<Runnable>(10000),//
        new DefaultThreadFactory()) {

    
protected void afterExecute(Runnable r, Throwable t) {
        
super.afterExecute(r, t);
        printException(r, t);
    }
};

private static void printException(Runnable r, Throwable t) {
    
if (t == null && r instanceof Future<?>) {
        
try {
            Future
<?> future = (Future<?>) r;
            
if (future.isDone())
                future.get();
        } 
catch (CancellationException ce) {
            t 
= ce;
        } 
catch (ExecutionException ee) {
            t 
= ee.getCause();
        } 
catch (InterruptedException ie) {
            Thread.currentThread().interrupt(); 
// ignore/reset
        }
    }
    
if (t != null)
        log.error(t.getMessage(), t);
}

此办法的关键在于Q事实上 afterExecute q不会L抛出异常 Throwable tQ通过查看源码得知Q异常是装在此时的Future对象中的Q?而此Future对象其实是一个java.util.concurrent.FutureTask的实玎ͼ默认的runҎ其实调用?java.util.concurrent.FutureTask.Sync.innerRun()?/v>

void innerRun() {
    if (!compareAndSetState(0, RUNNING))
        return;
    try {
        runner = Thread.currentThread();
        if (getState() == RUNNING) // recheck after setting thread
            innerSet(callable.call());
        else
            releaseShared(0); // cancel
    } catch (Throwable ex) {
        innerSetException(ex);
    }
}

void innerSetException(Throwable t) {
    for (;;) {
        int s = getState();
        if (s == RAN)
            return;
        if (s == CANCELLED) {
            // aggressively release to set runner to null,
            
// in case we are racing with a cancel request
            
// that will try to interrupt runner
            releaseShared(0);
            return;
        }
        if (compareAndSetState(s, RAN)) {
            exception = t;
            result = null;
            releaseShared(0);
            done();
            return;
        }
    }
}

q里我们可以看到它吃掉了异常Q将异常存储在java.util.concurrent.FutureTask.Sync的exception字段中:

/** The exception to throw from get() */
private Throwable exception;

当我们获取异步执行的l果Ӟ java.util.concurrent.FutureTask.get()

public V get() throws InterruptedException, ExecutionException {
    
return sync.innerGet();
}

java.util.concurrent.FutureTask.Sync.innerGet()

V innerGet() throws InterruptedException, ExecutionException {
    acquireSharedInterruptibly(
0);
    
if (getState() == CANCELLED)
        
throw new CancellationException();
    
if (exception != null)
        
throw new ExecutionException(exception);
    
return result;
}

异常׃被包装成ExecutionException异常抛出?/p>

也就是说当我们想U程?ThreadPoolExecutor(java.util.concurrent.ExecutorService)提交dӞ 如果不理会Q务结果(Feture.get()Q,那么此异常将被线E池吃掉?/p>

<T> Future<T> submit(Callable<T> task);
Future
<?> submit(Runnable task);

而java.util.concurrent.ScheduledThreadPoolExecutor是承ThreadPoolExecutor的,因此情况cM?/p>

l论Q通过覆盖ThreadPoolExecutor.afterExecute ҎQ我们才能捕获到d的异常(RuntimeExceptionQ?br />
原文地址Q?span style="font-family: verdana, 'courier new'; font-size: 14px; line-height: 21px;">
http://imxylz.com/blog/2013/08/02/handling-the-uncaught-exception-of-java-thread-pool/



imxylz 2013-08-05 16:45 发表评论
]]>
深入出 Java Concurrency (40): q发ȝ part 4 性能与׾~?/title><link>http://www.tkk7.com/xylz/archive/2011/12/31/367641.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Sat, 31 Dec 2011 06:13:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2011/12/31/367641.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/367641.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2011/12/31/367641.html#Feedback</comments><slash:comments>3</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/367641.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/367641.html</trackback:ping><description><![CDATA[<h1>性能与׾~?/h1> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">使用U程的一U说法是Z提高性能。多U程可以使程序充分利用闲|的资源Q提高资源的利用率,同时能够q行处理dQ提高系l的响应性?但是很显Ӟ引入U程的同时也引入了系l的复杂性。另外系l的性能q不是L随着U程数的增加而L提高?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>性能与׾~?/h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">性能的提升通常意味着可以用更的资源做更多的事情。这里资源是包括我们常说的CPU周期、内存、网l带宽、磁盘IO、数据库、WEB服务{等?引入多线E可以充分利用多核的优势Q充分利用IOd带来的gq,也可以降低网l开销带来的媄响,从而提高单位时间内的响应效率?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">Z提高性能Q需要有效的利用我们现有的处理资源,同时也要开拓新的可用资源。例如,对于CPU而言Q理想状况下希望CPU能够满负荷工作。当然这里满负荷工作是指做有用的事情Q而不是无谓的d@环或者等待。受限于CPU的计能力,如果CPU辑ֈ了极限,那么很显然我们充分利用了计算能力。对于IO而言Q内存、磁盘、网l等Q,如果辑ֈ了其对于的带宽,q些资源的利用率也就上去了。理想状况下所有资源的能力都被用完了,那么q个pȝ的性能辑ֈ了最大倹{?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">Z衡量pȝ的性能Q有一些指标用于定性、定量的分析。例如服务时间、等待时间、吞吐量、效率、可伸羃性、生成量{等。服务时间、等待时间等用于衡量pȝ的效率,卛_底有多快。吞吐量、生成量{用于衡量系l的定wQ即能够处理多少数据。除此之外,有效服务旉、中断时间等用于能力pȝ的可靠性和E_性等?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">可׾~性的意思是指增加计资源,吞吐量和生量相应得到的改进?从算法的角度Ԍ通常用复杂度来衡量其对应的性能。例如时间复杂度、空间复杂度{?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>Amdahl定律</h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">q行的Q务增加资源显然能够提高性能Q但是如果是串行的Q务,增加资源q不一定能够得到合理的性能提升?nbsp;<a rel="nofollow" style="text-decoration: none; ">Amdahl定律</a>描述的在一个系l中Q增加处理器资源对系l行的提升比率?假定在一个系l中QF是必M行化执行的比重,N是处理器资源Q那么随着N的增加最多增加的加速比Q?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <div style="font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><img src="http://www.tkk7.com/images/blogjava_net/xylz/amdahl.png" width="200" height="71" alt="" /></div> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">理论上,当N近于无I大Ӟ加速比最大值无限趋q于1/F?q意味着如果一个程序的串行化比重ؓ50%Q那么ƈ行化后最大加速比?倍?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">加速比除了可以用于加速的比率外,也可以用于衡量CPU资源的利用率。如果每一个CPU的资源利用率?00%Q那么CPU的资源每ơ翻倍时Q加速比也应该翻倍?事实上,在拥?0个处理器的系l中Q程序如果有10%是串行化的,那么最多可以加?/(0.1+(1-0.1)/10)=5.3倍,换句话说CPU的利用率只用5.3/10=53%。而如果处理器增加?00倍,那么加速比?.2倍,也就是说CPU的利用率只有?.3%?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">昄增加CPU的数量ƈ不能提高CPU的利用率。下图描q的是随着CPU的数量增加,不同串行化比重的pȝ的加速比?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <div style="font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><img src="http://www.tkk7.com/images/blogjava_net/xylz/utilization.png" width="495" height="306" alt="" /></div> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">很显Ӟ串行比重大Q增加CPU资源的效果越不明显?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>性能提升</h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">性能的提升可以从以下几个斚w入手?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>pȝq_的资源利用率</h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">一个程序对pȝq_的资源利用率是指某一个设备繁忙且服务于此E序的时间占所有时间的比率。从物理学的角度讲类g有用功的比率。简单的说就是:资源利用?有效J忙旉/总耗费旉?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">也就说尽可能的让讑֤做有用的功,同时榨取其最大倹{无用的循环可能会导致CPU 100%的用率Q但不一定是有效的工作。有效性通常难以衡量Q通常只能以主观来评估Q或者通过被优化的E序的行为来判断是否提高了有效性?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>延迟</h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">延迟描述的是完成d所耗费的时间。gq有时候也成ؓ响应旉。如果有多个q行的操作,那么延迟取决于耗费旉最大的d?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>多处?/h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">多处理是指在单一pȝ上同时执行多个进E或者多个程序的能力。多处理能力的好处是可以提高吞吐量。多处理可以有效利用多核CPU的资源?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>多线E?/h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">多线E描q的是同一个地址I间内同时执行多个线E的q程。这些线E都有不同的执行路径和不同的栈结构。我们说的ƈ发性更多的是指针对U程?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>q发?/h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">同时执行多个E序或者Q务称之ؓq发。单E序内的多Q务处理或者多E序间的多Q务处理都认ؓ是ƈ发?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>吞吐?/h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">吞吐量衡量系l在单位之间内可以完成的工作总量。对于硬件系l而言Q吞吐量是物理介质的上限。在没有辑ֈ物理介质之前Q提高系l的吞吐量也可以大幅度改q性能。同时吞吐量也是衡量性能的一个指标?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>瓉</h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">E序q行q程中性能最差的地方。通常而言Q串行的IO、磁盘IO、内存单元分配、网lIO{都可能造成瓉。某些用太频繁的算法也有可能成为瓶颈?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>可扩展?/h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">q里的可扩展性主要是指程序或pȝ通过增加可用的资源而增加性能的能力?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>U程开销</h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">假设引入的多U程都用于计,那么性能一定会有很大的提升么? 其实引入多线E以后也会引入更多的开销?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>切换上下?/h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">如果可运行的U程数大于CPU的内核数Q那么OS会根据一定的调度法Q强行切换正在运行的U程Q从而其它U程能够使用CPU周期?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">切换U程会导致上下文切换。线E的调度会导致CPU需要在操作pȝ和进E间p更多的时间片D,q样真正执行应用E序的时间就减少了。另外上下文切换也会D~存的频J进出,对于一个刚被切换的U程来说Q可能由于高速缓冲中没有数据而变得更慢,从而导致更多的IO开销?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>内存同步</h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">不同U程间要q行数据同步Qsynchronized以及volatile提供的可见性都会导致缓存失效。线E栈之间的数据要和主存进行同步,q些同步有一些小的开销。如果线E间同时要进行数据同步,那么q些同步的线E可能都会受阅R?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h3>d</h3> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">当发生锁竞争Ӟp|的线E会Dd。通常d的线E可能在JVM内部q行自旋{待Q或者被操作pȝ挂v。自旋等待可能会D更多的CPU切片费Q而操作系l挂起则会导致更多的上下文切换?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">了解了性能的提升的几个斚wQ也了解性能的开销后,应用E序pҎ实际的场景进行取舍和评估。没有一x逸的优化ҎQ不断的q行范围改q和调整是提高性能的有效手Dc当前一些大的架构调整也会导致较大的性能的提升?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">单的原则是在保证逻辑正确的情况小Q找到性能瓉Q小步改q和优化?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>参考资?/h2> <ul style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "> <li>Amdahl's law: <a rel="nofollow" style="text-decoration: none; ">http://en.wikipedia.org/wiki/Amdahl%27s_law</a></li> <li>Gustafson's law: <a rel="nofollow" style="text-decoration: none; ">http://en.wikipedia.org/wiki/Gustafson%27s_law</a></li> <li>Sun-Ni law: <a rel="nofollow" style="text-decoration: none; ">http://en.wikipedia.org/wiki/Sun-Ni_law</a></li> <li>多核pȝ中三U典型锁竞争的加速比分析 <a rel="nofollow" style="text-decoration: none; ">http://blog.csdn.net/drzhouweiming/article/details/1800319</a></li> <li>阿姆辑ְ定律和Gustafson定律的等h?nbsp;<a rel="nofollow" style="text-decoration: none; ">http://book.51cto.com/art/201004/197506.htm</a></li> </ul> <p> </p> <div class="qzknncp" id="index"> <div class="wwnmnbo" id="previous"><a href="http://www.tkk7.com/xylz/archive/2011/12/30/367592.html">q发ȝ part 3 常见的ƈ发陷?/a> </div> <div class="bfcuvus" id="center" align="center"><a href="http://www.tkk7.com/xylz/archive/2010/07/08/325587.html"><strong>?nbsp;  ?/strong></a> </div> <div class="uevsyut" id="next"><a name="over">暂时完结</a></div> </div><img src ="http://www.tkk7.com/xylz/aggbug/367641.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2011-12-31 14:13 <a href="http://www.tkk7.com/xylz/archive/2011/12/31/367641.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (39): q发ȝ part 3 常见的ƈ发陷?/title><link>http://www.tkk7.com/xylz/archive/2011/12/30/367592.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Fri, 30 Dec 2011 09:25:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2011/12/30/367592.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/367592.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2011/12/30/367592.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/367592.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/367592.html</trackback:ping><description><![CDATA[<h1>常见的ƈ发陷?/h1> <h2>volatile</h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">volatile只能数据的可见性,q不能保证原子操作和U程安全Q因此volatile不是万能的。参?a href="http://www.tkk7.com/xylz/archive/2010/07/03/325168.html" rel="nofollow" style="text-decoration: none; ">指o重排?/a></p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">volatile最常见于下面两U场景?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">a. 循环机?br /> </p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --><span style="color: #0000FF; ">volatile</span> <span style="color: #0000FF; ">boolean</span> done = <span style="color: #0000FF; ">false</span>;<br /> <img src="http://www.tkk7.com/Images/dot.gif" alt="" /><br /> <br />     <span style="color: #0000FF; ">while</span>( ! done ){<br />         dosomething();<br />     }</div> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><br /> b. 单例模型 Q?a href="http://www.tkk7.com/xylz/archive/2009/12/18/306622.html%ef%bc%89" rel="nofollow" style="text-decoration: none; ">http://www.tkk7.com/xylz/archive/2009/12/18/306622.htmlQ?br /> <br /> </a></p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --><a href="http://www.tkk7.com/xylz/archive/2009/12/18/306622.html%ef%bc%89" rel="nofollow" style="text-decoration: none; "><span style="color: #0000FF; ">public</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">class</span><span style="color: #000000; "> DoubleLockSingleton {<br /> <br />     </span><span style="color: #0000FF; ">private</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">static</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">volatile</span><span style="color: #000000; "> DoubleLockSingleton instance </span><span style="color: #000000; ">=</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">null</span><span style="color: #000000; ">;<br /> <br />     </span><span style="color: #0000FF; ">private</span><span style="color: #000000; "> DoubleLockSingleton() {<br />     }<br /> <br />     </span><span style="color: #0000FF; ">public</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">static</span><span style="color: #000000; "> DoubleLockSingleton getInstance() {<br />         </span><span style="color: #0000FF; ">if</span><span style="color: #000000; "> (instance </span><span style="color: #000000; ">==</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">null</span><span style="color: #000000; ">) {<br />             </span><span style="color: #0000FF; ">synchronized</span><span style="color: #000000; "> (DoubleLockSingleton.</span><span style="color: #0000FF; ">class</span><span style="color: #000000; ">) {<br />                 </span><span style="color: #0000FF; ">if</span><span style="color: #000000; "> (instance </span><span style="color: #000000; ">==</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">null</span><span style="color: #000000; ">) {<br />                     instance </span><span style="color: #000000; ">=</span><span style="color: #000000; "> </span><span style="color: #0000FF; ">new</span><span style="color: #000000; "> DoubleLockSingleton();<br />                 }<br />             }<br />         }<br />         </span><span style="color: #0000FF; ">return</span><span style="color: #000000; "> instance;<br />     }<br /> }</span></a></div> <p> </p> <h2><br /> synchronized/Lock</h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">看v来Lock有更好的性能以及更灵zȝ控制Q是否完全可以替换synchronizedQ?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">?a href="http://www.tkk7.com/xylz/archive/2010/07/16/326246.html" rel="nofollow" style="text-decoration: none; ">锁的一些其它问?/a>中说q,synchronized的性能随着JDK版本的升U会来高Q而Lock优化的空间受限于CPU的性能Q很有限。另外JDK内部的工PU程转储Q对synchronized是有一些支持的Q方便发现死锁等Q,而对Lock是没有Q何支持的?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">也就说简单的逻辑使用synchronized完全没有问题Q随着机器的性能的提高,q点开销是可以忽略的。而且从代码结构上讲是更简单的。简单就是美?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">对于复杂的逻辑Q如果涉及到d锁、条件变量、更高的吞吐量以及更灉|、动态的用法Q那么就可以考虑使用Lock。当然这里尤光要注意Lock的正用法?br /> </p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->Lock lock = <img src="http://www.tkk7.com/Images/dot.gif" alt="" /><br /> lock.lock();<br /> <span style="color: #0000FF; ">try</span>{<br />     <span style="color: #008000; ">//</span><span style="color: #008000; ">do something</span><span style="color: #008000; "><br /> </span>}<span style="color: #0000FF; ">finally</span>{<br />     lock.unlock();<br /> }</div> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><br /> 一定要Lock的释放放入finally块中Q否则一旦发生异常或者逻辑跌{Q很有可能会D锁没有释放,从而发生死锁。而且q种死锁是难以排查的?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">如果需要synchronized无法做到的尝试锁机制Q或者说担心发生死锁无法自恢复,那么使用tryLock()是一个比较明智的选择的?br /> </p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->Lock lock = <img src="http://www.tkk7.com/Images/dot.gif" alt="" /><br /> <span style="color: #0000FF; ">if</span>(lock.tryLock()){<br />     <span style="color: #0000FF; ">try</span>{<br />         <span style="color: #008000; ">//</span><span style="color: #008000; ">do something</span><span style="color: #008000; "><br /> </span>    }<span style="color: #0000FF; ">finally</span>{<br />         lock.unlock();<br />     }<br /> }</div> <p> </p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">甚至可以使用获取锁一D|间内时的机制Lock.tryLock(long,TimeUnit)?锁的使用可以参考前面文章的描述和徏议?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>锁的边界</h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">一个流行的错误是这L?br /> </p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->ConcurrentMap<String,String> map = <span style="color: #0000FF; ">new</span> ConcurrentHashMap<String,String>();<br /> <br /> <span style="color: #0000FF; ">if</span>(!map.containsKey(key)){<br />     map.put(key,value);<br /> }</div> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><br /> 看v来很合理的,对于一个线E安全的Map实现Q要存取一个不重复的结果,先检是否存在然后加入?其实我们知道两个原子操作和在一L指o序列不代表就是线E安全的?割裂的多个原子操作放在一起在多线E的情况下就有可能发生错误?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">实际上ConcurrentMap提供了putIfAbsent(K, V)?#8220;原子操作”机制Q这{h于下面的逻辑Q?br /> </p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --><span style="color: #0000FF; ">if</span>(map.containsKey(key)){<br />     <span style="color: #0000FF; ">return</span> map.get(key);<br /> }<span style="color: #0000FF; ">else</span>{<br />     <span style="color: #0000FF; ">return</span> map.put(k,v);<br /> }</div> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><br /> 除了putIfAbsentq有replace(K, V)以及replace(K, V, V)两种机制来完成组合的操作?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">提到MapQ这里有一谈<a href="http://www.tkk7.com/xylz/archive/2009/12/18/306602.html" rel="nofollow" style="text-decoration: none; ">HashMapdq发</a>的问题?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>构造函数启动线E?/h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">下面的实例是在构造函C启动一个线E?br /> </p> <div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all"><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --><span style="color: #0000FF; ">public</span> <span style="color: #0000FF; ">class</span> Runner{<br />    <span style="color: #0000FF; ">int</span> x,y;<br />    Thread thread;<br />    <span style="color: #0000FF; ">public</span> Runner(){<br />       <span style="color: #0000FF; ">this</span>.x=1;<br />       <span style="color: #0000FF; ">this</span>.y=2;<br />       <span style="color: #0000FF; ">this</span>.thread=<span style="color: #0000FF; ">new</span> MyThread();<br />       <span style="color: #0000FF; ">this</span>.thread.start();<br />    }<br /> }</div> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><br /> q里可能存在的陷阱是如果此类被承,那么启动的线E可能无法正读取子cȝ初始化操作?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">因此一个简单的原则是,止在构造函C启动U程Q可以考虑但是提供一个方法来启动U程。如果非要这么做Q最好将c设|ؓfinalQ禁止ѝ?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>丢失通知的问?/h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><a href="http://www.tkk7.com/xylz/archive/2011/09/05/326988.html" rel="nofollow" style="text-decoration: none; ">q篇文章</a>里面提到qnotify丢失通知的问题?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">对于wait/notify/notifyAll以及await/singal/singalAllQ如果不定到底是否能够正确的收到消息,担心丢失通知Q简单一点就是L通知所有?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">如果担心只收Cơ消息,使用循环一直监听是不错的选择?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">非常ȝ性能的系l,可能需要区分到底是通知单个q是通知所有的挂v者?/p> <div style="margin-top: 1.33em; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "></div> <h2>U程?/h2> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">q不是线E数多好Q在下一文章里面会具体了解下性能和可伸羃性?单的_U程数多没有一个固定的l论Q受限于CPU的内核数QIO的性能以及依赖的服务等{。因此选择一个合适的U程数有助于提高吞吐量?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">对于CPU密集型应用,U程数和CPU的内核数一致有助于提高吞吐量,所有CPU都很J忙Q效率就很高?对于IO密集型应用,U程数受限于IO的性能Q某些时候单U程可能比多U程效率更高。但通常情况下适当提高U程敎ͼ有利于提高网lIO的效率,因ؓ我们L认ؓ|络IO的效率比较低?/p> <p style="margin-top: 1.33em; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; ">对于U程池而言Q选择合适的U程C及Q务队列是提高U程池效率的手段?br /> </p> <div style="font-size: 13px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-style: solid; border-right-style: solid; border-bottom-style: solid; border-left-style: solid; border-top-color: #cccccc; border-right-color: #cccccc; border-bottom-color: #cccccc; border-left-color: #cccccc; border-image: initial; padding-right: 5px; padding-bottom: 4px; padding-left: 4px; padding-top: 4px; width: 98%; word-break: break-all; background-color: #eeeeee; "><!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --><span style="color: #0000FF; ">public</span> ThreadPoolExecutor(<br />     <span style="color: #0000FF; ">int</span> corePoolSize,<br />     <span style="color: #0000FF; ">int</span> maximumPoolSize,<br />     <span style="color: #0000FF; ">long</span> keepAliveTime,<br />     TimeUnit unit,<br />     BlockingQueue<Runnable> workQueue,<br />     ThreadFactory threadFactory,<br />     RejectedExecutionHandler handler)</div> <p> </p> <p style="margin-top: 0px; margin-bottom: 0px; font-family: Arial, Helvetica, sans-serif; font-size: 15px; line-height: 19px; background-color: #ffffff; "><br /> 对于U程池来_如果dL有积压,那么可以适当提高corePoolSize大小Q如果机器负载较低,那么可以适当提高maximumPoolSize的大;d队列不长的情况下减小keepAliveTime的时间有助于降低负蝲Q另外Q务队列的长度以及d队列?a href="http://www.tkk7.com/xylz/archive/2011/01/18/343183.html" rel="nofollow" style="text-decoration: none; ">拒绝{略</a>也会对Q务的处理有一些媄响?/p> <p> </p> <div class="qgxoftp" id="index"> <div class="fisnthv" id="previous"><a href="http://www.tkk7.com/xylz/archive/2011/12/29/367480.html">q发ȝ part 2 常见的ƈ发场?/a> </div> <div class="gxhjpdg" id="center" align="center"><a href="http://www.tkk7.com/xylz/archive/2010/07/08/325587.html"><strong>?nbsp;  ?/strong></a> </div> <div class="xwytzcq" id="next"><a href="http://www.tkk7.com/xylz/archive/2011/12/31/367641.html">q发ȝ part 4 性能与׾~?/a> </div> </div><img src ="http://www.tkk7.com/xylz/aggbug/367592.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2011-12-30 17:25 <a href="http://www.tkk7.com/xylz/archive/2011/12/30/367592.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (38): q发ȝ part 2 常见的ƈ发场?/title><link>http://www.tkk7.com/xylz/archive/2011/12/29/367480.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Thu, 29 Dec 2011 08:31:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2011/12/29/367480.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/367480.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2011/12/29/367480.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/367480.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/367480.html</trackback:ping><description><![CDATA[     摘要: U程?<br> <br>q发最常见用于U程池,昄使用U程池可以有效的提高吞吐量?<br>最常见、比较复杂一个场景是Web容器的线E池。Web容器使用U程池同步或者异步处理HTTPhQ同时这也可以有效的复用HTTPq接Q降低资源申L开销。通常我们认ؓHTTPh旉常昂늚Qƈ且也是比较耗费资源和性能的,所以线E池在这里就扮演了非帔R要的角色?<br>在线E池的章节中非常详细的讨ZU程池的原理和用,同时也提CQ线E池的配|和参数Ҏ能的媄响是巨大的。不如此,受限于资源(机器的性能、网l的带宽{等Q、依赖的服务Q客L的响应速度{,U程池的威力也不会一直增ѝ达CU程池的瓉后,性能和吞吐量都会大幅度降低?<br>一直增加机器的性能或者增大线E的个数Qƈ不一定能有效的提高吞吐量。高q发的情况下Q机器的负蝲会大q提升,q时候机器的E_性、服务的可靠性都会下降?<br>管如此Q线E池依然是提高吞吐量的一个有效措施,配合合适的参数能够有效的充分利用资源,提高资源的利用率?nbsp; <a href='http://www.tkk7.com/xylz/archive/2011/12/29/367480.html'>阅读全文</a><img src ="http://www.tkk7.com/xylz/aggbug/367480.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2011-12-29 16:31 <a href="http://www.tkk7.com/xylz/archive/2011/12/29/367480.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (37): q发ȝ part 1 死锁与活跃度http://www.tkk7.com/xylz/archive/2011/12/29/365149.htmlimxylzimxylzThu, 29 Dec 2011 06:04:00 GMThttp://www.tkk7.com/xylz/archive/2011/12/29/365149.htmlhttp://www.tkk7.com/xylz/comments/365149.htmlhttp://www.tkk7.com/xylz/archive/2011/12/29/365149.html#Feedback2http://www.tkk7.com/xylz/comments/commentRss/365149.htmlhttp://www.tkk7.com/xylz/services/trackbacks/365149.html
前面谈了很多q发的特性和工具Q但是大部分都是和锁有关的。我们用锁来保证线E安全,但是q也会引起一些问题?
锁顺序死?lock-ordering deadlock)Q多个线E试N过不同的顺序获得多个相同的资源Q则发生的@环锁依赖现象?
动态的锁顺序死锁(Dynamic Lock Order DeadlocksQ:多个U程通过传递不同的锁造成的锁序死锁问题?
资源死锁QResource DeadlocksQ:U程间相互等待对Ҏ有的锁,q且谁都不会释放自己持有的锁发生的死锁。也是说当现场持有和等待的目标成ؓ资源Q就有可能发生此死锁。这和锁序死锁不一L地方是,竞争的资源之间ƈ没有严格先后序Q仅仅是怺依赖而已?nbsp; 阅读全文

imxylz 2011-12-29 14:04 发表评论
]]>
深入出 Java Concurrency (36): U程?part 9 q发操作异常体系http://www.tkk7.com/xylz/archive/2011/07/12/354206.htmlimxylzimxylzTue, 12 Jul 2011 15:15:00 GMThttp://www.tkk7.com/xylz/archive/2011/07/12/354206.htmlhttp://www.tkk7.com/xylz/comments/354206.htmlhttp://www.tkk7.com/xylz/archive/2011/07/12/354206.html#Feedback3http://www.tkk7.com/xylz/comments/commentRss/354206.htmlhttp://www.tkk7.com/xylz/services/trackbacks/354206.htmlq发包引入的工具cd多方法都会抛Z定的异常Q这些异常描qCd在线E池中执行时发生的例外情况,而通常q些例外需要应用程序进行捕捉和处理?/p>

例如在Future接口中有如下一个APIQ?/p>

 

java.util.concurrent.Future.get(long, TimeUnit) throws InterruptedException, ExecutionException, TimeoutException;

 

?a href="http://www.tkk7.com/xylz/archive/2011/02/13/344207.html" target="_blank">前面的章?/a>中描qCFuturecȝ具体实现原理。这里不再讨论,但是比较好奇的抛出的三个异常?/p>

q里有一文章(Java 理论与实? 处理 InterruptedExceptionQ描qCInterruptedException的来源和处理方式。简单的说就是线E在执行的过E中被自己或者别Z断了。这时候ؓ了响应中断就需要处理当前的异常?/p>

对于java.lang.Thread而言QInterruptedException也是一个很诡异的问题?/p>

中断一个线EThread.interrupt()时会触发下面一U情况:

如果U程在调?Object cȝ wait()、wait(long) ?wait(long, int) ҎQ或者该cȝ join()、join(long)、join(long, int)、sleep(long) ?sleep(long, int) Ҏq程中受阻,则其中断状态将被清除,它还收C?InterruptedException?/p>

一个线E的中断状态描q是q样的Thread.interrupted()Q?/strong>

试当前U程是否已经中断。线E的中断状?/em> pҎ清除。换句话_如果q箋两次调用该方法,则第二次调用返?falseQ在W一ơ调用已清除了其中断状态之后,且第二次调用验完中断状态前Q当前线E再ơ中断的情况除外Q?nbsp;

也就是说如果到一个线E已l被中断了,那么U程的用方Q挂赗等待或者正在执行)都将应该得到一个中断异常,同时会清除异常中断状态?/p>

 

V innerGet(long nanosTimeout) throws InterruptedException, ExecutionException, TimeoutException {
    
if (!tryAcquireSharedNanos(0, nanosTimeout))
        
throw new TimeoutException();
    
if (getState() == CANCELLED)
        
throw new CancellationException();
    
if (exception != null)
        
throw new ExecutionException(exception);
    
return result;
}

 

上面获取dl果的方法实CQ将在获取锁的过E中得到一个中断异常。代码java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireSharedNanos(int, long)描述了这U情况:

    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
    
if (Thread.interrupted())
        
throw new InterruptedException();
    
return tryAcquireShared(arg) >= 0 ||
        doAcquireSharedNanos(arg, nanosTimeout);
    }

 


q里在获取锁的时候检线E中断情况,如果被中断则清除中断位,同时抛出一个中断异常。ؓ什么如此做Q因为我们的U程在线E池中是被重复执行的Q所以一旦线E被中断后ƈ不会退出线E,而是讄中断位,{候Q务队列自己处理线E,从而达到线E被重复利用的目的。有兴趣的可以参考代码java.util.concurrent.ThreadPoolExecutor.Worker.runTask(Runnable)。这里在关闭U程池时׃D中断所有线E?/p>

除了InterruptedException 异常我们q发C一个全新的异常java.util.concurrent.TimeoutExceptionQ此异常是用来描qCQ务执行时间超q了期望{待旉Q也许是一直没有获取到锁,也许是还没有执行完成?/p>

在innerGet代码片段中我们看刎ͼ如果U程在指定的旉无法获取到锁Q那么就会得C个超时异常。这个很好理解,比如如果执行一个非常耗时的网lQ务,我们不希望Q务一直等待从而占用大量的资源Q可能在一定时间后׃希望取消此操作。此时超时异常很好的描述了这U需求?/p>

与此同时Q如果取消了一个Q务,那么再次从Q务中获取执行l果Q那么将会得C个Q务被取消的异常java.util.concurrent.CancellationException?/p>

除了上述异常外,q将得到一个java.util.concurrent.ExecutionException异常Q?/p>

q是因ؓ我们的提交的djava.util.concurrent.Callable在call()Ҏ中允许抛ZQ何异常,另外常规的线E执行也可能抛出一个RuntimeExceptionQ所以这里简单包装了下所有异常,当作执行q程中发生的异常ExecutionException抛出?/p>

以上是整个异常体系Q所有ƈ发操作的异常都可以归l于上述几类?/p>

很多情况下处理时间长度都是用java.util.concurrent.TimeUnitQ这是一个枚丄型,用来描述旉长度。其中内|了一些长度的单位。其中包括纳U、微U、毫U、秒、分、时、天。例如超时操?U,可以使用

Future.get(5,TimeUnit.SECONDS) 或?Future.get(5000L,TimeUnit.MILLISECONDS)

当然一U单位的旉转换成另一U单位的旉也是非常方便的。另外还有线E的sleep/join以及对象的wait操作的便h作?/p>

 



imxylz 2011-07-12 23:15 发表评论
]]>
深入出 Java Concurrency (35): U程?part 8 U程池的实现及原?(3)http://www.tkk7.com/xylz/archive/2011/02/13/344207.htmlimxylzimxylzSun, 13 Feb 2011 12:21:00 GMThttp://www.tkk7.com/xylz/archive/2011/02/13/344207.htmlhttp://www.tkk7.com/xylz/comments/344207.htmlhttp://www.tkk7.com/xylz/archive/2011/02/13/344207.html#Feedback6http://www.tkk7.com/xylz/comments/commentRss/344207.htmlhttp://www.tkk7.com/xylz/services/trackbacks/344207.htmll合上节U程池的原理和实玎ͼd分析了线E池对Q务的l果处理Q尤其是对gq、周期性Q务是如何执行的?
q也是ƈ发系列中源码分析的最后一节?nbsp; 阅读全文

imxylz 2011-02-13 20:21 发表评论
]]>
深入出 Java Concurrency (34): U程?part 7 U程池的实现及原?(2)http://www.tkk7.com/xylz/archive/2011/02/11/344091.htmlimxylzimxylzFri, 11 Feb 2011 15:48:00 GMThttp://www.tkk7.com/xylz/archive/2011/02/11/344091.htmlhttp://www.tkk7.com/xylz/comments/344091.htmlhttp://www.tkk7.com/xylz/archive/2011/02/11/344091.html#Feedback2http://www.tkk7.com/xylz/comments/commentRss/344091.htmlhttp://www.tkk7.com/xylz/services/trackbacks/344091.html阅读全文

imxylz 2011-02-11 23:48 发表评论
]]>
深入出 Java Concurrency (33): U程?part 6 U程池的实现及原?(1)http://www.tkk7.com/xylz/archive/2011/01/18/343183.htmlimxylzimxylzTue, 18 Jan 2011 15:43:00 GMThttp://www.tkk7.com/xylz/archive/2011/01/18/343183.htmlhttp://www.tkk7.com/xylz/comments/343183.htmlhttp://www.tkk7.com/xylz/archive/2011/01/18/343183.html#Feedback4http://www.tkk7.com/xylz/comments/commentRss/343183.htmlhttp://www.tkk7.com/xylz/services/trackbacks/343183.htmlU程池需要支持多个线Eƈ发执行,因此有一个线E集合Collection来执行线EQ务;
涉及d的异步执行,因此需要有一个集合来~存d队列CollectionQ?
很显然在多个U程之间协调多个dQ那么就需要一个线E安全的d集合Q同时还需要支持阻塞、超时操作,那么BlockingQueue是必不可的Q?
既然是线E池Q出发点是提高pȝ性能同时降低资源消耗,那么U程池的大小有限制Q因此需要有一个核心线E池大小Q线E个敎ͼ和一个最大线E池大小Q线E个敎ͼQ有一个计数用来描q当前线E池大小Q?
如果是有限的U程池大,那么长时间不使用的线E资源就应该销毁掉Q这样就需要一个线E空闲时间的计数来描q线E何时被销毁;
前面描述q线E池也是有生命周期的Q因此需要有一个状态来描述U程池当前的q行状态;
U程池的d队列如果有边界,那么需要有一个Q务拒l策略来处理q多的Q务,同时在线E池的销毁阶D也需要有一个Q务拒l策略来处理新加入的dQ?
上面U?nbsp; 阅读全文

imxylz 2011-01-18 23:43 发表评论
]]>
深入出 Java Concurrency (32): U程?part 5 周期性Q务调?/title><link>http://www.tkk7.com/xylz/archive/2011/01/10/342738.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Mon, 10 Jan 2011 15:39:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2011/01/10/342738.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/342738.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2011/01/10/342738.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/342738.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/342738.html</trackback:ping><description><![CDATA[     摘要: 在JDK 5.0之前Qjava.util.Timer/TimerTask是唯一的内|Q务调度方法,而且在很长一D|间里很热衷于使用q种方式q行周期性Q务调度?<br>首先研究下Timer/TimerTask的特性(至于javax.swing.Timer׃再研I了Q?<br>上面三段代码反映了Timer/TimerTask的以下特性: <br>Timer对Q务的调度是基于绝Ҏ间的?<br>所有的TimerTask只有一个线ETimerThread来执行,因此同一时刻只有一个TimerTask在执行?<br>M一个TimerTask的执行异帔R会导致Timerl止所有Q务?<br>׃Zl对旉q且是单U程执行Q因此在多个d调度Ӟ长时间执行的d被执行后有可能导致短旉d快速在短时间内被执行多ơ或者干脆丢弃多个Q务?nbsp; <a href='http://www.tkk7.com/xylz/archive/2011/01/10/342738.html'>阅读全文</a><img src ="http://www.tkk7.com/xylz/aggbug/342738.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2011-01-10 23:39 <a href="http://www.tkk7.com/xylz/archive/2011/01/10/342738.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (31): U程?part 4 U程池Q务拒l策?/title><link>http://www.tkk7.com/xylz/archive/2011/01/08/342609.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Sat, 08 Jan 2011 14:47:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2011/01/08/342609.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/342609.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2011/01/08/342609.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/342609.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/342609.html</trackback:ping><description><![CDATA[     摘要: 上一节中提到关闭U程池过E中需要对新提交的dq行处理。这个是java.util.concurrent.RejectedExecutionHandler处理的逻辑?<br> <br>在没有分析线E池原理之前先来分析下ؓ什么有d拒绝的情况发生?<br>q里先假设一个前提:U程池有一个Q务队列,用于~存所有待处理的Q务,正在处理的Q务将从Q务队列中U除。因此在d队列长度有限的情况下׃出现CQ务的拒绝处理问题Q需要有一U策略来处理应该加入d队列却因为队列已满无法加入的情况。另外在U程池关闭的时候也需要对d加入队列操作q行额外的协调处理?<br> <br>RejectedExecutionHandler提供了四U方式来处理d拒绝{略?nbsp; <a href='http://www.tkk7.com/xylz/archive/2011/01/08/342609.html'>阅读全文</a><img src ="http://www.tkk7.com/xylz/aggbug/342609.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2011-01-08 22:47 <a href="http://www.tkk7.com/xylz/archive/2011/01/08/342609.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (30): U程?part 3 Executor 生命周期http://www.tkk7.com/xylz/archive/2011/01/04/342316.htmlimxylzimxylzTue, 04 Jan 2011 14:54:00 GMThttp://www.tkk7.com/xylz/archive/2011/01/04/342316.htmlhttp://www.tkk7.com/xylz/comments/342316.htmlhttp://www.tkk7.com/xylz/archive/2011/01/04/342316.html#Feedback5http://www.tkk7.com/xylz/comments/commentRss/342316.htmlhttp://www.tkk7.com/xylz/services/trackbacks/342316.html我们知道U程是有多种执行状态的Q同L理线E的U程池也有多U状态。JVM会在所有线E(非后台daemonU程Q全部终止后才退出,Z节省资源和有效释放资源关闭一个线E池显得很重要。有时候无法正的关闭U程池,会LJVM的结束?
U程池Executor是异步的执行dQ因此Q何时M能够直接获取提交的Q务的状态。这些Q务有可能已经完成Q也有可能正在执行或者还在排队等待执行。因此关闭线E池可能出现一下几U情况:
q缓关闭Q已l启动的d全部执行完毕Q同时不再接受新的Q?
立即关闭Q取消所有正在执行和未执行的d
另外关闭U程池后对于d的状态应该有相应的反馈信息?nbsp; 阅读全文

imxylz 2011-01-04 22:54 发表评论
]]>
深入出 Java Concurrency (29): U程?part 2 Executor 以及Executorshttp://www.tkk7.com/xylz/archive/2010/12/21/341281.htmlimxylzimxylzTue, 21 Dec 2010 15:32:00 GMThttp://www.tkk7.com/xylz/archive/2010/12/21/341281.htmlhttp://www.tkk7.com/xylz/comments/341281.htmlhttp://www.tkk7.com/xylz/archive/2010/12/21/341281.html#Feedback2http://www.tkk7.com/xylz/comments/commentRss/341281.htmlhttp://www.tkk7.com/xylz/services/trackbacks/341281.html下面q张囑֮整描qCU程池的cMpȝ构?nbsp; 阅读全文

imxylz 2010-12-21 23:32 发表评论
]]>
深入出 Java Concurrency (28): U程?part 1 ?/title><link>http://www.tkk7.com/xylz/archive/2010/12/19/341098.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Sun, 19 Dec 2010 05:24:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2010/12/19/341098.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/341098.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2010/12/19/341098.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/341098.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/341098.html</trackback:ping><description><![CDATA[     摘要: 从这一节开始正式进入线E池的部分。其实整个体pdl拖了很长的旉Q因此后面的章节会加快速度Q甚臛_是一个半成品或者简单化Q以后有旉的慢慢补充、完善?<br>其实U程池是q发包里面很重要的一部分Q在实际情况中也是用很多的一个重要组件?<br>下图描述的是U程池API的一部分。广义上的完整线E池可能q包括Thread/Runnable、Timer/TimerTask{部分。这里只介绍主要的和高的API以及架构和原理?nbsp; <a href='http://www.tkk7.com/xylz/archive/2010/12/19/341098.html'>阅读全文</a><img src ="http://www.tkk7.com/xylz/aggbug/341098.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2010-12-19 13:24 <a href="http://www.tkk7.com/xylz/archive/2010/12/19/341098.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (27): q发容器 part 12 U程安全的List/Sethttp://www.tkk7.com/xylz/archive/2010/11/23/338853.htmlimxylzimxylzTue, 23 Nov 2010 14:22:00 GMThttp://www.tkk7.com/xylz/archive/2010/11/23/338853.htmlhttp://www.tkk7.com/xylz/comments/338853.htmlhttp://www.tkk7.com/xylz/archive/2010/11/23/338853.html#Feedback1http://www.tkk7.com/xylz/comments/commentRss/338853.htmlhttp://www.tkk7.com/xylz/services/trackbacks/338853.html在《ƈ发队列与Queue介》中介绍了ƈ发容器的一个概括,主要描述的是Queue的实现。其中特别提C点LinkedList是List/Queue的实玎ͼ但是LinkedList实非线E安全的。不BlockingQueueq是ConcurrentMap的实玎ͼ我们发现都是针对链表的实玎ͼ当然可能的使用CAS或者Lock的特性,同时都有通过锁部分容器来提供q发的特性。而对于List或者Set而言Q增、删操作其实都是针对整个容器Q因此每ơ操作都不可避免的需要锁定整个容器空_性能肯定会大打折扣。要实现一个线E安全的List/SetQ只需要在修改操作的时候进行同步即可,比如使用java.util.Collections.synchronizedList(List)或者java.util.Collections.synchronizedSet(Set)。当然也可以使用Lock来实现线E安全的List/Set?
通常情况下我们的高ƈ发都发生在“多d写”的情况Q因此如?nbsp; 阅读全文

imxylz 2010-11-23 22:22 发表评论
]]>
深入出 Java Concurrency (26): q发容器 part 11 Exchangerhttp://www.tkk7.com/xylz/archive/2010/11/22/338733.htmlimxylzimxylzMon, 22 Nov 2010 14:31:00 GMThttp://www.tkk7.com/xylz/archive/2010/11/22/338733.htmlhttp://www.tkk7.com/xylz/comments/338733.htmlhttp://www.tkk7.com/xylz/archive/2010/11/22/338733.html#Feedback0http://www.tkk7.com/xylz/comments/commentRss/338733.htmlhttp://www.tkk7.com/xylz/services/trackbacks/338733.html换句话说Exchanger提供的是一个交换服务,允许原子性的交换两个Q多个)对象Q但同时只有一Ҏ会成功。先看一个简单的实例模型?nbsp; 阅读全文

imxylz 2010-11-22 22:31 发表评论
]]>
深入出 Java Concurrency (25): q发容器 part 10 双向q发d队列 BlockingDequehttp://www.tkk7.com/xylz/archive/2010/08/18/329227.htmlimxylzimxylzWed, 18 Aug 2010 08:01:00 GMThttp://www.tkk7.com/xylz/archive/2010/08/18/329227.htmlhttp://www.tkk7.com/xylz/comments/329227.htmlhttp://www.tkk7.com/xylz/archive/2010/08/18/329227.html#Feedback4http://www.tkk7.com/xylz/comments/commentRss/329227.htmlhttp://www.tkk7.com/xylz/services/trackbacks/329227.html
首先看下LinkedBlockingDeque的数据结构。通常情况下从数据l构上就能看U实现的优缺点,q样q道如何更好的使用工具了?nbsp; 阅读全文

imxylz 2010-08-18 16:01 发表评论
]]>
深入出 Java Concurrency (24): q发容器 part 9 双向队列集合 Dequehttp://www.tkk7.com/xylz/archive/2010/08/12/328587.htmlimxylzimxylzWed, 11 Aug 2010 16:13:00 GMThttp://www.tkk7.com/xylz/archive/2010/08/12/328587.htmlhttp://www.tkk7.com/xylz/comments/328587.htmlhttp://www.tkk7.com/xylz/archive/2010/08/12/328587.html#Feedback4http://www.tkk7.com/xylz/comments/commentRss/328587.htmlhttp://www.tkk7.com/xylz/services/trackbacks/328587.html有一D|间没有更C。接着上节l箋吧?
Queue除了前面介绍的实现外Q还有一U双向的Queue实现Deque。这U队列允许在队列头和Nq行入队出队操作Q因此在功能上比Queue昄要更复杂。下图描q的是Deque的完整体pd。需要说明的是LinkedList也已l加入了Deque的一部分QLinkedList是从jdk1.2 开始就存在数据l构Q?nbsp; 阅读全文

imxylz 2010-08-12 00:13 发表评论
]]>
深入出 Java Concurrency (23): q发容器 part 8 可阻塞的BlockingQueue (3)http://www.tkk7.com/xylz/archive/2010/07/30/327582.htmlimxylzimxylzFri, 30 Jul 2010 08:15:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/30/327582.htmlhttp://www.tkk7.com/xylz/comments/327582.htmlhttp://www.tkk7.com/xylz/archive/2010/07/30/327582.html#Feedback0http://www.tkk7.com/xylz/comments/commentRss/327582.htmlhttp://www.tkk7.com/xylz/services/trackbacks/327582.html在Set中有一个排序的集合SortedSetQ用来保存按照自焉序排列的对象。Queue中同样引入了一个支持排序的FIFO模型?
q发队列与Queue?中介l了QPriorityQueue和PriorityBlockingQueue是支持排序的Queue。显然一个支持阻塞的排序Queue要比一个非U程安全的Queue实现h要复杂的多,因此下面只介lPriorityBlockingQueueQ至于PriorityQueue只需要去掉Blocking功能基本相同了?nbsp; 阅读全文

imxylz 2010-07-30 16:15 发表评论
]]>
深入出 Java Concurrency (22): q发容器 part 7 可阻塞的BlockingQueue (2)http://www.tkk7.com/xylz/archive/2010/07/27/327265.htmlimxylzimxylzTue, 27 Jul 2010 14:04:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/27/327265.htmlhttp://www.tkk7.com/xylz/comments/327265.htmlhttp://www.tkk7.com/xylz/archive/2010/07/27/327265.html#Feedback0http://www.tkk7.com/xylz/comments/commentRss/327265.htmlhttp://www.tkk7.com/xylz/services/trackbacks/327265.html对于一个Queue而言Q同样可以用数l实现。用数l的好处在于各个元素之间原生是通过数组的烦引关联v来的Q一ơ元素之间就是有序的Q在通过索引操作数组方便多了。当然也有它不利的一面,扩容h比较ȝQ同时删除一个元素也比较低效?
ArrayBlockingQueue 是Queue的一U数l实现?nbsp; 阅读全文

imxylz 2010-07-27 22:04 发表评论
]]>
深入出 Java Concurrency (21): q发容器 part 6 可阻塞的BlockingQueue (1)http://www.tkk7.com/xylz/archive/2010/07/24/326988.htmlimxylzimxylzFri, 23 Jul 2010 16:02:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/24/326988.htmlhttp://www.tkk7.com/xylz/comments/326988.htmlhttp://www.tkk7.com/xylz/archive/2010/07/24/326988.html#Feedback5http://www.tkk7.com/xylz/comments/commentRss/326988.htmlhttp://www.tkk7.com/xylz/services/trackbacks/326988.htmlBlockingQueue相对于Queue而言增加了两个操作:put/take。下面是一张整理的表格?nbsp; 阅读全文

imxylz 2010-07-24 00:02 发表评论
]]>
深入出 Java Concurrency (20): q发容器 part 5 ConcurrentLinkedQueuehttp://www.tkk7.com/xylz/archive/2010/07/23/326934.htmlimxylzimxylzFri, 23 Jul 2010 06:11:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/23/326934.htmlhttp://www.tkk7.com/xylz/comments/326934.htmlhttp://www.tkk7.com/xylz/archive/2010/07/23/326934.html#Feedback0http://www.tkk7.com/xylz/comments/commentRss/326934.htmlhttp://www.tkk7.com/xylz/services/trackbacks/326934.html一个基于链接节点的无界U程安全队列。此队列按照 FIFOQ先q先出)原则对元素进行排序。队列的头部 是队列中旉最长的元素。队列的N 是队列中旉最短的元素。新的元素插入到队列的尾部,队列获取操作从队列头部获得元素。当多个U程׃n讉K一个公?collection ӞConcurrentLinkedQueue 是一个恰当的选择。此队列不允怋?null 元素?

׃ConcurrentLinkedQueue只是单的实现了一个队列QueueQ因此从API的角度讲Q没有多值的介绍Q用v来也很简单,和前面遇到的所有FIFO队列都类伹{出队列只能操作头节点,入队列只能操作尾节点QQ意节Ҏ作就需要遍历完整的队列?
重点攑֜解释ConcurrentLinkedQueue的原理和实现上?nbsp; 阅读全文

imxylz 2010-07-23 14:11 发表评论
]]>
深入出 Java Concurrency (19): q发容器 part 4 q发队列与Queue?/title><link>http://www.tkk7.com/xylz/archive/2010/07/21/326723.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Wed, 21 Jul 2010 04:21:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2010/07/21/326723.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/326723.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2010/07/21/326723.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/326723.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/326723.html</trackback:ping><description><![CDATA[     摘要: Queue是JDK 5以后引入的新的集合类Q它属于Java Collections Framework的成员,在Collection集合中和List/Set是同一U别的接口。通常来讲Queue描述的是一UFIFO的队列,当然不全都是Q比如PriorityQueue是按照优先的顺序(或者说是自焉序,借助于Comparator接口Q?<br>下图描述了Java Collections Framework中Queue的整个家族体pR?<br>对于Queue而言是在Collection的基上增加了offer/remove/poll/element/peekҎQ另外重新定义了addҎ。对于这六个ҎQ有不同的定义?nbsp; <a href='http://www.tkk7.com/xylz/archive/2010/07/21/326723.html'>阅读全文</a><img src ="http://www.tkk7.com/xylz/aggbug/326723.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2010-07-21 12:21 <a href="http://www.tkk7.com/xylz/archive/2010/07/21/326723.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (18): q发容器 part 3 ConcurrentMap (3)http://www.tkk7.com/xylz/archive/2010/07/20/326661.htmlimxylzimxylzTue, 20 Jul 2010 09:48:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/20/326661.htmlhttp://www.tkk7.com/xylz/comments/326661.htmlhttp://www.tkk7.com/xylz/archive/2010/07/20/326661.html#Feedback7http://www.tkk7.com/xylz/comments/commentRss/326661.htmlhttp://www.tkk7.com/xylz/services/trackbacks/326661.html
ConcurrentHashMap原理

在读写锁章节部分介绍q一U是用读写锁实现Map的方法。此U方法看h可以实现Map响应的功能,而且吞吐量也应该不错。但是通过前面对读写锁原理的分析后知道Q读写锁的适合场景是读操作>>写操作,也就是读操作应该占据大部分操作,另外d锁存在一个很严重的问题是d操作不能同时发生。要惌册写同时进行问题(臛_不同元素的读写分)Q那么就只能锁拆分Q不同的元素拥有不同的锁Q这U技术就是“锁分离”技术?
默认情况下ConcurrentHashMap是用?6个类似HashMap 的结构,其中每一个HashMap拥有一个独占锁。也是说最l的效果是通过某种Hash法Q将M一个元素均匀的映到某个HashMap的Map.Entry上面Q而对某个一个元素的操作集中在其分布的HashMap上,与其它HashMap无关。这样就支持最?6个ƈ发的写操作?nbsp; 阅读全文

imxylz 2010-07-20 17:48 发表评论
]]>
深入出 Java Concurrency (17): q发容器 part 2 ConcurrentMap (2)http://www.tkk7.com/xylz/archive/2010/07/20/326584.htmlimxylzimxylzMon, 19 Jul 2010 16:22:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/20/326584.htmlhttp://www.tkk7.com/xylz/comments/326584.htmlhttp://www.tkk7.com/xylz/archive/2010/07/20/326584.html#Feedback2http://www.tkk7.com/xylz/comments/commentRss/326584.htmlhttp://www.tkk7.com/xylz/services/trackbacks/326584.html要谈ConcurrentHashMap的构造,׃得不谈HashMap的构造,因此先从HashMap开始简单介l?

HashMap原理
我们从头开始设惟뀂要对象存攑֜一P如何设计q个容器。目前只有两条\可以赎ͼ一U是采用分格技术,每一个对象存放于一个格子中Q这样通过Ҏ子的~号p取到或者遍历对象;另一U技术就是采用串联的方式Q将各个对象串联hQ这需要各个对象至带有下一个对象的索引Q或者指针)。显然第一U就是数l的概念Q第二种是链表的概c所有的容器的实现其实都是基于这两种方式的,不管是数l还是链表,或者二者俱有。HashMap采用的就是数l的方式?
有了存取对象的容器后q需要以下两个条件才能完成Map所需要的条g?nbsp; 阅读全文

imxylz 2010-07-20 00:22 发表评论
]]>
深入出 Java Concurrency (16): q发容器 part 1 ConcurrentMap (1)http://www.tkk7.com/xylz/archive/2010/07/19/326527.htmlimxylzimxylzMon, 19 Jul 2010 07:25:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/19/326527.htmlhttp://www.tkk7.com/xylz/comments/326527.htmlhttp://www.tkk7.com/xylz/archive/2010/07/19/326527.html#Feedback7http://www.tkk7.com/xylz/comments/commentRss/326527.htmlhttp://www.tkk7.com/xylz/services/trackbacks/326527.html在JDK 1.4以下只有Vector和Hashtable是线E安全的集合Q也Uƈ发容器,Collections.synchronized*pd也可以看作是U程安全的实玎ͼ。从JDK 5开始增加了U程安全的Map接口ConcurrentMap和线E安全的队列BlockingQueueQ尽Queue也是同时期引入的新的集合Q但是规范ƈ没有规定一定是U程安全的,事实上一些实C不是U程安全的,比如PriorityQueue、ArrayDeque、LinkedList{,在Queue章节中会具体讨论q些队列的结构图和实玎ͼ?

在介lConcurrencyMap之前先来回顾下Map的体pȝ构。下图描qCMap的体pȝ构,其中蓝色字体的是JDK 5以后新增的ƈ发容器?nbsp; 阅读全文

imxylz 2010-07-19 15:25 发表评论
]]>
深入出 Java Concurrency (15): 锁机?part 10 锁的一些其它问?/title><link>http://www.tkk7.com/xylz/archive/2010/07/16/326246.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Thu, 15 Jul 2010 16:15:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2010/07/16/326246.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/326246.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2010/07/16/326246.html#Feedback</comments><slash:comments>2</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/326246.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/326246.html</trackback:ping><description><![CDATA[     摘要: <br>主要谈谈锁的性能以及其它一些理论知识,内容主要的出处是《Java Concurrency in Practice》,l合自己的理解和实际应用寚w机制q行一个小的ȝ?<br> <br>首先需要强调的一ҎQ所有锁Q包括内|锁和高U锁Q都是有性能消耗的Q也是说在高ƈ发的情况下,׃锁机制带来的上下文切换、资源同步等消耗是非常可观的。在某些极端情况下,U程在锁上的消耗可能比U程本n的消耗还要多。所以如果可能的话,在Q何情况下都尽量少用锁Q如果不可避免那么采用非d法是一个不错的解决ҎQ但是却也不是绝对的?nbsp; <a href='http://www.tkk7.com/xylz/archive/2010/07/16/326246.html'>阅读全文</a><img src ="http://www.tkk7.com/xylz/aggbug/326246.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2010-07-16 00:15 <a href="http://www.tkk7.com/xylz/archive/2010/07/16/326246.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>《深入浅?Java Concurrency》目?/title><link>http://www.tkk7.com/xylz/archive/2010/07/08/325587.html</link><dc:creator>imxylz</dc:creator><author>imxylz</author><pubDate>Thu, 08 Jul 2010 11:17:00 GMT</pubDate><guid>http://www.tkk7.com/xylz/archive/2010/07/08/325587.html</guid><wfw:comment>http://www.tkk7.com/xylz/comments/325587.html</wfw:comment><comments>http://www.tkk7.com/xylz/archive/2010/07/08/325587.html#Feedback</comments><slash:comments>33</slash:comments><wfw:commentRss>http://www.tkk7.com/xylz/comments/commentRss/325587.html</wfw:commentRss><trackback:ping>http://www.tkk7.com/xylz/services/trackbacks/325587.html</trackback:ping><description><![CDATA[<p>q是一份完整的Java q发整理W记Q记录了我最q几q学习Javaq发的一些心得和体会?/p> <p> </p> <ol> <li><a href="http://www.tkk7.com/xylz/archive/2010/06/30/324915.html">J.U.C 整体认识</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/01/324988.html">原子操作 part 1 从AtomicInteger开?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/02/325079.html">原子操作 part 2 数组、引用的原子操作</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/03/325168.html">原子操作 part 3 指o重排序与happens-before法则</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/04/325206.html">原子操作 part 4 CAS操作</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/05/325274.html">锁机?part 1 Lock与ReentrantLock</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/06/325390.html">锁机?part 2 AQS </a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/07/325410.html">锁机?part 3 加锁的原?(Lock.lock)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/08/325540.html">锁机?part 4 锁释放与条g变量 (Lock.unlock And Condition)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/09/325612.html">锁机?part 5 闭锁 (CountDownLatch)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/12/325913.html">锁机?part 6 CyclicBarrier</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/13/326021.html">锁机?part 7 信号?(Semaphore)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/14/326080.html">锁机?part 8 d?(ReentrantReadWriteLock) (1)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/15/326152.html">锁机?part 9 d?(ReentrantReadWriteLock) (2)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/16/326246.html">锁机?part 10 锁的一些其它问?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/19/326527.html">q发容器 part 1 ConcurrentMap (1)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/20/326584.html">q发容器 part 2 ConcurrentMap (2)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/20/326661.html">q发容器 part 3 ConcurrentMap (3)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/21/326723.html">q发容器 part 4 q发队列与Queue?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/23/326934.html">q发容器 part 5 ConcurrentLinkedQueue </a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/24/326988.html">q发容器 part 6 可阻塞的BlockingQueue (1)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/27/327265.html">q发容器 part 7 可阻塞的BlockingQueue (2)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/07/30/327582.html">q发容器 part 8 可阻塞的BlockingQueue (3)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/08/12/328587.html">q发容器 part 9 双向队列集合 Deque</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/08/18/329227.html">q发容器 part 10 双向q发d队列 BlockingDeque</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/11/22/338733.html">q发容器 part 11 Exchanger</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/11/23/338853.html">q发容器 part 12 U程安全的List/Set CopyOnWriteArrayList/CopyOnWriteArraySet</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/12/19/341098.html">U程?part 1 ?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2010/12/21/341281.html">U程?part 2 Executor 以及Executors</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/01/04/342316.html">U程?part 3 Executor 生命周期</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/01/08/342609.html">U程?part 4 U程池Q务拒l策?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/01/10/342738.html">U程?part 5 周期性Q务调?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/01/18/343183.html">U程?part 6 U程池的实现及原?(1)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/02/11/344091.html">U程?part 7 U程池的实现及原?(2)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/02/13/344207.html">U程?part 8 U程池的实现及原?(3)</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/07/12/354206.html">U程?part 9 q发操作异常体系</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/12/29/365149.html">q发ȝ part 1 死锁与活跃度</a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/12/29/367480.html">q发ȝ part 2 常见的ƈ发场?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/12/30/367592.html">q发ȝ part 3 常见的ƈ发陷?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2011/12/31/367641.html">q发ȝ part 4  性能与׾~?/a></li> <li><a href="http://www.tkk7.com/xylz/archive/2013/08/05/402405.html">捕获JavaU程池执行Q务抛出的异常</a></li> </ol> <p> </p> <div class="khctkgy" id="index"> <div class="gkjpgrm" id="previous"></div> <div class="mcwcivn" id="center" align="center"></div> <div class="jkmlnuf" id="next"><a href="http://www.tkk7.com/xylz/archive/2010/06/30/324915.html">J.U.C的整体认?/a></div> <a href="http://www.tkk7.com/xylz/archive/2010/06/30/324915.html"> </a></div> <a href="http://www.tkk7.com/xylz/archive/2010/06/30/324915.html"> <p> </p> <p>最后更新时_ 2013-08-05 16:47</p> </a><img src ="http://www.tkk7.com/xylz/aggbug/325587.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.tkk7.com/xylz/" target="_blank">imxylz</a> 2010-07-08 19:17 <a href="http://www.tkk7.com/xylz/archive/2010/07/08/325587.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>深入出 Java Concurrency (4): 原子操作 part 3 指o重排序与happens-before法则http://www.tkk7.com/xylz/archive/2010/07/03/325168.htmlimxylzimxylzSat, 03 Jul 2010 12:40:00 GMThttp://www.tkk7.com/xylz/archive/2010/07/03/325168.htmlhttp://www.tkk7.com/xylz/comments/325168.htmlhttp://www.tkk7.com/xylz/archive/2010/07/03/325168.html#Feedback16http://www.tkk7.com/xylz/comments/commentRss/325168.htmlhttp://www.tkk7.com/xylz/services/trackbacks/325168.html׃在下一个章节中会谈到锁机制Q因此此节中会适当引入锁的概念?
在Java Concurrency in Practice中是q样定义U程安全的:
当多个线E访问一个类Ӟ如果不用考虑q些U程在运行时环境下的调度和交替运行,q且不需要额外的同步及在调用方代码不必做其他的协调,q个cȝ行ؓ仍然是正的Q那么这个类是U程安全的?nbsp; 阅读全文

imxylz 2010-07-03 20:40 发表评论
]]>
վ֩ģ壺 㽶ѿƬƵapp| 鸣ۺĻһƵ1 | ββ8xѾþ| ձһƷƵ| һëƬѿ˾| ҹƷþþþþapp| ҹAVպAVȫ| Ļ뾫ƷԴ| ββ8xѾþ| ѿ߿Aվ| ƷһƵ| ƵƷѹۿƵ| ۺϼ޵һҳ| ޸һ| ɫ߹ۿ| | þֹƷۺ| AƵһ| ѹۿ| ѻɫëƬƵ| ѻɫһëƬ| ձɫڹۿ| һëƬ߲Ƶ| ˾Ʒ| þþþþùƷ | պ߾Ʒһ| Ƶ69½| ˽Ƶ75| պƷƵַ| ߳aëƬѲ| ѿaƬ߹ۿ| Ů18ëƬëƬѹۿ| 㻨ѸƵ| ؼAƬëƬ69| Ƶһ| ˬAëƬѿ| ߲ŸԲ| ȫɫƴɫƬѾþ| ȾѾƷ| ޳avƬþ| þþƷƷ|